storybook 10.1.0-beta.3 → 10.1.0-beta.4

package/dist/common/index.d.ts

@@ -1,5 +1,5 @@
 import * as storybook_internal_types from 'storybook/internal/types';
-import { CLIOptions, LoadOptions, BuilderOptions, StorybookConfigRaw, PresetConfig, CoreCommon_ResolvedAddonPreset, CoreCommon_ResolvedAddonVirtual, LoadedPreset, Presets, PackageJson, CoreCommon_AddonInfo, SupportedFramework, SupportedRenderer, SupportedBuilder, Options as Options$2, CoreWebpackCompiler, CoreCommon_StorybookInfo, Ref, StorybookConfig, StoriesEntry, NormalizedStoriesSpecifier } from 'storybook/internal/types';
+import { CLIOptions, LoadOptions, BuilderOptions, StorybookConfigRaw, PresetConfig, CoreCommon_ResolvedAddonPreset, CoreCommon_ResolvedAddonVirtual, LoadedPreset, Presets, CoreCommon_AddonInfo, SupportedFramework, SupportedRenderer, SupportedBuilder, Options as Options$2, CoreWebpackCompiler, CoreCommon_StorybookInfo, Ref, StorybookConfig, StoriesEntry, NormalizedStoriesSpecifier, PackageJson } from 'storybook/internal/types';
 export { PackageJson } from 'storybook/internal/types';
 import { WriteStream } from 'node:fs';
 import { Buffer } from 'node:buffer';
@@ -172,188 +172,598 @@ type MergeExclusive<FirstType, SecondType> =
 		(Without<FirstType, SecondType> & SecondType) | (Without<SecondType, FirstType> & FirstType) :
 		FirstType | SecondType;
 
-type StdioOption =
-	| 'pipe'
-	| 'overlapped'
-	| 'ipc'
-	| 'ignore'
-	| 'inherit'
-	| Stream
-	| number
-	| undefined;
+declare function temporaryDirectory({ prefix }?: {
+    prefix?: string | undefined;
+}): Promise<string>;
+type FileOptions = MergeExclusive<{
+    /**
+     * File extension.
+     *
+     * Mutually exclusive with the `name` option.
+     *
+     * _You usually won't need this option. Specify it only when actually needed._
+     */
+    readonly extension?: string;
+}, {
+    /**
+     * Filename.
+     *
+     * Mutually exclusive with the `extension` option.
+     *
+     * _You usually won't need this option. Specify it only when actually needed._
+     */
+    readonly name?: string;
+}>;
+declare function temporaryFile({ name, extension }?: FileOptions): Promise<string>;
+declare function parseList(str: string): string[];
+declare function getEnvConfig(program: Record<string, any>, configEnv: Record<string, any>): void;
+/**
+ * Given a file name, creates an object with utilities to manage a log file. It creates a temporary
+ * log file which you can manage with the returned functions. You can then decide whether to move
+ * the log file to the users project, or remove it.
+ *
+ * @example
+ *
+ * ```ts
+ * const { logStream, moveLogFile, removeLogFile, clearLogFile, readLogFile } =
+ *   await createLogStream('my-log-file.log');
+ *
+ * // SCENARIO 1:
+ * // you can write custom messages to generate a log file
+ * logStream.write('my log message');
+ * await moveLogFile();
+ *
+ * // SCENARIO 2:
+ * // or you can pass it to stdio and capture the output of that command
+ * try {
+ *   await executeCommand({
+ *     command: 'pnpm',
+ *     args: ['info', packageName, ...args],
+ *     // do not output to the user, and send stdio and stderr to log file
+ *     stdio: ['ignore', logStream, logStream],
+ *   });
+ * } catch (err) {
+ *   // do something with the log file content
+ *   const output = await readLogFile();
+ *   // move the log file to the users project
+ *   await moveLogFile();
+ * }
+ * // success, no need to keep the log file
+ * await removeLogFile();
+ * ```
+ */
+declare const createLogStream: (logFileName?: string) => Promise<{
+    moveLogFile: () => Promise<void>;
+    removeLogFile: () => Promise<void>;
+    clearLogFile: () => Promise<void>;
+    readLogFile: () => Promise<string>;
+    logStream: WriteStream;
+}>;
+declare const isCorePackage: (pkg: string) => boolean;
+declare const isSatelliteAddon: (pkg: string) => boolean;
 
-type EncodingOption =
-  | 'utf8'
-  // eslint-disable-next-line unicorn/text-encoding-identifier-case
-  | 'utf-8'
-  | 'utf16le'
-  | 'utf-16le'
-  | 'ucs2'
-  | 'ucs-2'
-  | 'latin1'
-  | 'binary'
-  | 'ascii'
-  | 'hex'
-  | 'base64'
-  | 'base64url'
-  | 'buffer'
-  | null
-  | undefined;
-type DefaultEncodingOption = 'utf8';
+interface Options$1 {
+    before: CoreCommon_AddonInfo;
+    after: CoreCommon_AddonInfo;
+    configFile: string;
+    getConfig: (path: string) => any;
+}
+declare const checkAddonOrder: ({ before, after, configFile, getConfig }: Options$1) => Promise<void>;
 
-type CommonOptions<EncodingType extends EncodingOption = DefaultEncodingOption> = {
-	/**
-	Kill the spawned process when the parent process exits unless either:
-		- the spawned process is [`detached`](https://nodejs.org/api/child_process.html#child_process_options_detached)
-		- the parent process is terminated abruptly, for example, with `SIGKILL` as opposed to `SIGTERM` or a normal exit
+declare function loadEnvs(options?: {
+    production?: boolean;
+}): Promise<{
+    stringified: Record<string, string>;
+    raw: Record<string, string>;
+}>;
+declare const stringifyEnvs: (raw: Record<string, string>) => Record<string, string>;
+declare const stringifyProcessEnvs: (raw: Record<string, string>) => Record<string, string>;
+declare const optionalEnvToBoolean: (input: string | undefined) => boolean | undefined;
+/**
+ * Consistently determine if we are in a CI environment
+ *
+ * Doing Boolean(process.env.CI) or !process.env.CI is not enough, because users might set CI=false
+ * or CI=0, which would be truthy, and thus return true in those cases.
+ */
+declare function isCI(): boolean | undefined;
 
-	@default true
-	*/
-	readonly cleanup?: boolean;
+declare const commonGlobOptions: (glob: string) => {
+    ignore?: undefined;
+} | {
+    ignore: string[];
+};
 
-	/**
-	Prefer locally installed binaries when looking for a binary to execute.
+declare const frameworkToRenderer: Record<SupportedFramework | SupportedRenderer, SupportedRenderer>;
+declare const frameworkToBuilder: Record<SupportedFramework, SupportedBuilder>;
 
-	If you `$ npm install foo`, you can then `execa('foo')`.
+/**
+ * Builder options can be specified in `core.builder.options` or `framework.options.builder`.
+ * Preference is given here to `framework.options.builder` if both are specified.
+ */
+declare function getBuilderOptions<T extends Record<string, any>>(options: Options$2): Promise<T | Record<string, never>>;
 
-	@default `true` with `$`, `false` otherwise
-	*/
-	readonly preferLocal?: boolean;
+/** Framework can be a string or an object. This utility always returns the string name. */
+declare function getFrameworkName(options: Options$2): Promise<string>;
+/**
+ * Extracts the proper framework name from the given framework field. The framework field can be the
+ * framework package name or a path to the framework package.
+ *
+ * @example
+ *
+ * ```ts
+ * extractFrameworkPackageName('/path/to/@storybook/angular'); // => '@storybook/angular'
+ * extractFrameworkPackageName('@third-party/framework'); // => '@third-party/framework'
+ * ```
+ */
+declare const extractFrameworkPackageName: (framework: string) => string;
 
-	/**
-	Preferred path to find locally installed binaries in (use with `preferLocal`).
+/**
+ * Render is set as a string on core. It must be set by the framework It falls back to the framework
+ * name if not set
+ */
+declare function getRendererName(options: Options$2): Promise<string>;
+/**
+ * Extracts the proper renderer name from the given framework name.
+ *
+ * @example
+ *
+ * ```ts
+ * extractRenderer('@storybook/react'); // => 'react'
+ * extractRenderer('@storybook/angular'); // => 'angular'
+ * extractRenderer('@third-party/framework'); // => null
+ * ```
+ *
+ * @param frameworkName The name of the framework.
+ * @returns The name of the renderer.
+ */
+declare function extractRenderer(frameworkName: string): Promise<storybook_internal_types.SupportedRenderer | null>;
 
-	@default process.cwd()
-	*/
-	readonly localDir?: string | URL;
+declare function getStorybookConfiguration(storybookScript: string, shortName: string, longName: string): string | null;
 
-	/**
-	Path to the Node.js executable to use in child processes.
+declare const rendererPackages: Record<string, SupportedRenderer>;
+declare const frameworkPackages: Record<string, SupportedFramework>;
+declare const builderPackages: Record<string, SupportedBuilder>;
+declare const compilerPackages: Record<string, CoreWebpackCompiler>;
+declare const findConfigFile: (prefix: string, configDir: string) => string | null;
+declare const getConfigInfo: (configDir?: string) => {
+    configDir: string;
+    mainConfigPath: string | null;
+    previewConfigPath: string | null;
+    managerConfigPath: string | null;
+};
+declare const getStorybookInfo: (configDir?: string, cwd?: string) => Promise<CoreCommon_StorybookInfo>;
 
-	This can be either an absolute path or a path relative to the `cwd` option.
+declare const getAutoRefs: (options: Options$2) => Promise<Record<string, Ref>>;
+declare function getRefs(options: Options$2): Promise<Record<string, Ref>>;
 
-	Requires `preferLocal` to be `true`.
+declare function globToRegexp(glob: string): RegExp;
 
-	For example, this can be used together with [`get-node`](https://github.com/ehmicky/get-node) to run a specific Node.js version in a child process.
+declare class HandledError extends Error {
+    handled: boolean;
+    constructor(error: unknown);
+}
 
-	@default process.execPath
-	*/
-	readonly execPath?: string;
+/**
+ * Return a string corresponding to template filled with bindings using following pattern: For each
+ * (key, value) of `bindings` replace, in template, `{{key}}` by escaped version of `value`
+ *
+ * @param template {String} Template with `{{binding}}`
+ * @param bindings {Object} key-value object use to fill the template, `{{key}}` will be replaced by
+ *   `escaped(value)`
+ * @returns {String} Filled template
+ */
+declare const interpolate: (template: string, bindings: Record<string, string>) => string;
 
-	/**
-	Buffer the output from the spawned process. When set to `false`, you must read the output of `stdout` and `stderr` (or `all` if the `all` option is `true`). Otherwise the returned promise will not be resolved/rejected.
+interface PackageMeta {
+    name: string;
+    version: string;
+    [key: string]: any;
+}
 
-	If the spawned process fails, `error.stdout`, `error.stderr`, and `error.all` will contain the buffered data.
+interface ToString {
+    toString(): string;
+}
 
-	@default true
-	*/
-	readonly buffer?: boolean;
+type StringOrToString = string | ToString;
 
-	/**
-	Same options as [`stdio`](https://nodejs.org/dist/latest-v6.x/docs/api/child_process.html#child_process_options_stdio).
+/**
+ * Callback invoked when resolving asynchronously
+ *
+ * @param error
+ * @param resolved Absolute path to resolved identifier
+ */
+type resolveCallback = (err: Error | null, resolved?: string, pkg?: PackageMeta) => void;
 
-	@default `inherit` with `$`, `pipe` otherwise
-	*/
-	readonly stdin?: StdioOption;
+/**
+ * Callback invoked when checking if a file or directory exists
+ *
+ * @param error
+ * @param exists If the given file or directory exists
+ */
+type existsCallback = (err: Error | null, isFile?: boolean) => void;
 
-	/**
-	Same options as [`stdio`](https://nodejs.org/dist/latest-v6.x/docs/api/child_process.html#child_process_options_stdio).
-
-	@default 'pipe'
-	*/
-	readonly stdout?: StdioOption;
+/**
+ * Callback invoked when reading a file
+ *
+ * @param error
+ * @param isFile If the given file exists
+ */
+type readFileCallback = (err: Error | null, file?: StringOrToString) => void;
 
-	/**
-	Same options as [`stdio`](https://nodejs.org/dist/latest-v6.x/docs/api/child_process.html#child_process_options_stdio).
+/**
+ * Callback invoked when resolving a potential symlink
+ *
+ * @param error
+ * @param resolved Absolute path to the resolved file
+ */
+type realpathCallback = (err: Error | null, resolved?: string) => void;
 
-	@default 'pipe'
-	*/
-	readonly stderr?: StdioOption;
+/**
+ * Callback invoked when reading and parsing a package.json file
+ *
+ * @param error
+ * @param resolved Absolute path to the resolved file
+ */
+type readPackageCallback = (err: Error | null, package?: Record<string, unknown>) => void;
 
-	/**
-	Setting this to `false` resolves the promise with the error instead of rejecting it.
+/**
+ * Synchronously resolve the module path string id, returning the result and throwing an error when id can't be resolved.
+ *
+ * @param id Identifier to resolve
+ * @param options Options to use for resolving, optional.
+ */
+declare function resolveSync(id: string, opts?: resolve.SyncOpts): string;
 
-	@default true
-	*/
-	readonly reject?: boolean;
+/**
+ * Return whether a package is in core
+ */
+declare function resolveIsCore(id: string): boolean | undefined;
 
-	/**
-	Add an `.all` property on the promise and the resolved value. The property contains the output of the process with `stdout` and `stderr` interleaved.
+// https://github.com/Microsoft/TypeScript/issues/3496#issuecomment-128553540
+type JSONValue = string | number | boolean | JSONObject | JSONArray;
+interface JSONObject {
+    [x: string]: JSONValue;
+}
+interface JSONArray extends Array<JSONValue> {}
 
-	@default false
-	*/
-	readonly all?: boolean;
+/**
+ * Asynchronously resolve the module path string id into cb(err, res [, pkg]), where pkg (if defined) is the data from package.json
+ *
+ * @param id Identifier to resolve
+ * @param callback
+ */
+declare function resolve(id: string, cb: resolveCallback): void;
 
-	/**
-	Strip the final [newline character](https://en.wikipedia.org/wiki/Newline) from the output.
+/**
+ * Asynchronously resolve the module path string id into cb(err, res [, pkg]), where pkg (if defined) is the data from package.json
+ *
+ * @param id Identifier to resolve
+ * @param options Options to use for resolving, optional.
+ * @param callback
+ */
+declare function resolve(id: string, opts: resolve.AsyncOpts, cb: resolveCallback): void;
 
-	@default true
-	*/
-	readonly stripFinalNewline?: boolean;
+declare namespace resolve {
+    export type PackageJSON = JSONObject;
 
-	/**
-	Set to `false` if you don't want to extend the environment variables when providing the `env` property.
+    interface Opts {
+        /** directory to begin resolving from (defaults to __dirname) */
+        basedir?: string | undefined;
+        /** package.json data applicable to the module being loaded */
+        package?: any;
+        /** set to false to exclude node core modules (e.g. fs) from the search */
+        includeCoreModules?: boolean | undefined;
+        /** array of file extensions to search in order (defaults to ['.js']) */
+        extensions?: string | readonly string[] | undefined;
+        /** transform the parsed package.json contents before looking at the "main" field */
+        packageFilter?: ((pkg: PackageJSON, pkgFile: string, dir: string) => PackageJSON) | undefined;
+        /** transform a path within a package */
+        pathFilter?: ((pkg: PackageJSON, path: string, relativePath: string) => string) | undefined;
+        /** require.paths array to use if nothing is found on the normal node_modules recursive walk (probably don't use this) */
+        paths?: string | readonly string[] | undefined;
+        /** return the list of candidate paths where the packages sources may be found (probably don't use this) */
+        packageIterator?:
+            | ((request: string, start: string, getPackageCandidates: () => string[], opts: Opts) => string[])
+            | undefined;
+        /** directory (or directories) in which to recursively look for modules. (default to 'node_modules') */
+        moduleDirectory?: string | readonly string[] | undefined;
+        /**
+         * if true, doesn't resolve `basedir` to real path before resolving.
+         * This is the way Node resolves dependencies when executed with the --preserve-symlinks flag.
+         *
+         * Note: this property is currently true by default but it will be changed to false in the next major version because Node's resolution
+         * algorithm does not preserve symlinks by default.
+         */
+        preserveSymlinks?: boolean | undefined;
+    }
 
-	@default true
-	*/
-	readonly extendEnv?: boolean;
+    interface BaseAsyncOpts extends Opts {
+        /** function to asynchronously test whether a file exists */
+        isFile?: ((file: string, cb: existsCallback) => void) | undefined;
+        /** function to asynchronously test whether a directory exists */
+        isDirectory?: ((directory: string, cb: existsCallback) => void) | undefined;
+        /** function to asynchronously resolve a potential symlink to its real path */
+        realpath?: ((file: string, cb: realpathCallback) => void) | undefined;
+    }
 
-	/**
-	Current working directory of the child process.
+    export type AsyncOpts =
+        & BaseAsyncOpts
+        & ({
+            /** how to read files asynchronously (defaults to fs.readFile) */
+            readFile?: ((file: string, cb: readFileCallback) => void) | undefined;
+            /** function to asynchronously read and parse a package.json file */
+            readPackage?: never | undefined;
+        } | {
+            /** how to read files asynchronously (defaults to fs.readFile) */
+            readFile?: never | undefined;
+            /** function to asynchronously read and parse a package.json file */
+            readPackage?:
+                | ((
+                    readFile: (file: string, cb: readFileCallback) => void,
+                    pkgfile: string,
+                    cb: readPackageCallback,
+                ) => void)
+                | undefined;
+        });
 
-	@default process.cwd()
-	*/
-	readonly cwd?: string | URL;
+    interface BaseSyncOpts extends Opts {
+        /** function to synchronously test whether a file exists */
+        isFile?: ((file: string) => boolean) | undefined;
+        /** function to synchronously test whether a directory exists */
+        isDirectory?: ((directory: string) => boolean) | undefined;
+        /** function to synchronously resolve a potential symlink to its real path */
+        realpathSync?: ((file: string) => string) | undefined;
+    }
 
-	/**
-	Environment key-value pairs. Extends automatically from `process.env`. Set `extendEnv` to `false` if you don't want this.
+    export type SyncOpts =
+        & BaseSyncOpts
+        & ({
+            /** how to read files synchronously (defaults to fs.readFileSync) */
+            readFileSync?: ((file: string) => StringOrToString) | undefined;
+            /** function to synchronously read and parse a package.json file */
+            readPackageSync?: never | undefined;
+        } | {
+            /** how to read files synchronously (defaults to fs.readFileSync) */
+            readFileSync?: never | undefined;
+            /** function to synchronously read and parse a package.json file */
+            readPackageSync?:
+                | ((
+                    readFileSync: (file: string) => StringOrToString,
+                    pkgfile: string,
+                ) => Record<string, unknown> | undefined)
+                | undefined;
+        });
 
-	@default process.env
-	*/
-	readonly env?: NodeJS.ProcessEnv;
+    export var sync: typeof resolveSync;
+    export var isCore: typeof resolveIsCore;
+}
 
-	/**
-	Explicitly set the value of `argv[0]` sent to the child process. This will be set to `command` or `file` if not specified.
-	*/
-	readonly argv0?: string;
+declare const supportedExtensions: readonly [".js", ".ts", ".jsx", ".tsx", ".mjs", ".mts", ".mtsx", ".cjs", ".cts", ".ctsx"];
+declare function getInterpretedFile(pathToFile: string): string | undefined;
+declare function resolveImport(id: string, options: resolve.SyncOpts): string;
 
-	/**
-	Child's [stdio](https://nodejs.org/api/child_process.html#child_process_options_stdio) configuration.
+declare function serverRequire(filePath: string | string[]): Promise<any> | null;
 
-	@default 'pipe'
-	*/
-	readonly stdio?: 'pipe' | 'overlapped' | 'ignore' | 'inherit' | readonly StdioOption[];
+declare function loadMainConfig({ configDir, cwd, skipCache, }: {
+    configDir: string;
+    cwd?: string;
+    skipCache?: boolean;
+}): Promise<StorybookConfig>;
 
-	/**
-	Specify the kind of serialization used for sending messages between processes when using the `stdio: 'ipc'` option or `execaNode()`:
-		- `json`: Uses `JSON.stringify()` and `JSON.parse()`.
-		- `advanced`: Uses [`v8.serialize()`](https://nodejs.org/api/v8.html#v8_v8_serialize_value)
+declare function loadManagerOrAddonsFile({ configDir }: {
+    configDir: string;
+}): string | undefined;
 
-	[More info.](https://nodejs.org/api/child_process.html#child_process_advanced_serialization)
+declare function loadPreviewOrConfigFile({ configDir }: {
+    configDir: string;
+}): string | undefined;
 
-	@default 'json'
-	*/
-	readonly serialization?: 'json' | 'advanced';
+declare function logConfig(caption: unknown, config: unknown): void;
 
-	/**
-	Prepare child to run independently of its parent process. Specific behavior [depends on the platform](https://nodejs.org/api/child_process.html#child_process_options_detached).
+declare const DEFAULT_FILES_PATTERN = "**/*.@(mdx|stories.@(js|jsx|mjs|ts|tsx))";
+declare const getDirectoryFromWorkingDir: ({ configDir, workingDir, directory, }: NormalizeOptions & {
+    directory: string;
+}) => string;
+declare const normalizeStoriesEntry: (entry: StoriesEntry, { configDir, workingDir, defaultFilesPattern }: NormalizeOptions) => NormalizedStoriesSpecifier;
+interface NormalizeOptions {
+    configDir: string;
+    workingDir: string;
+    defaultFilesPattern?: string;
+}
+declare const normalizeStories: (entries: StoriesEntry[], options: NormalizeOptions) => NormalizedStoriesSpecifier[];
 
-	@default false
-	*/
-	readonly detached?: boolean;
+declare const getProjectRoot: () => string;
+declare const invalidateProjectRootCache: () => void;
+/** Finds files in the directory tree up to the project root */
+declare const findFilesUp: (matchers: string[], baseDir?: string) => string[];
+declare const nodePathsToArray: (nodePath: string) => string[];
+/** Ensures that a path starts with `./` or `../`, or is entirely `.` or `..` */
+declare function normalizeStoryPath(filename: string): string;
 
-	/**
-	Sets the user identity of the process.
-	*/
-	readonly uid?: number;
+declare function readTemplate(filename: string): Promise<string>;
 
-	/**
-	Sets the group identity of the process.
-	*/
-	readonly gid?: number;
+type StdioOption =
+	| 'pipe'
+	| 'overlapped'
+	| 'ipc'
+	| 'ignore'
+	| 'inherit'
+	| Stream
+	| number
+	| undefined;
 
-	/**
-	If `true`, runs `command` inside of a shell. Uses `/bin/sh` on UNIX and `cmd.exe` on Windows. A different shell can be specified as a string. The shell should understand the `-c` switch on UNIX or `/d /s /c` on Windows.
+type EncodingOption =
+  | 'utf8'
+  // eslint-disable-next-line unicorn/text-encoding-identifier-case
+  | 'utf-8'
+  | 'utf16le'
+  | 'utf-16le'
+  | 'ucs2'
+  | 'ucs-2'
+  | 'latin1'
+  | 'binary'
+  | 'ascii'
+  | 'hex'
+  | 'base64'
+  | 'base64url'
+  | 'buffer'
+  | null
+  | undefined;
+type DefaultEncodingOption = 'utf8';
+
+type CommonOptions<EncodingType extends EncodingOption = DefaultEncodingOption> = {
+	/**
+	Kill the spawned process when the parent process exits unless either:
+		- the spawned process is [`detached`](https://nodejs.org/api/child_process.html#child_process_options_detached)
+		- the parent process is terminated abruptly, for example, with `SIGKILL` as opposed to `SIGTERM` or a normal exit
+
+	@default true
+	*/
+	readonly cleanup?: boolean;
+
+	/**
+	Prefer locally installed binaries when looking for a binary to execute.
+
+	If you `$ npm install foo`, you can then `execa('foo')`.
+
+	@default `true` with `$`, `false` otherwise
+	*/
+	readonly preferLocal?: boolean;
+
+	/**
+	Preferred path to find locally installed binaries in (use with `preferLocal`).
+
+	@default process.cwd()
+	*/
+	readonly localDir?: string | URL;
+
+	/**
+	Path to the Node.js executable to use in child processes.
+
+	This can be either an absolute path or a path relative to the `cwd` option.
+
+	Requires `preferLocal` to be `true`.
+
+	For example, this can be used together with [`get-node`](https://github.com/ehmicky/get-node) to run a specific Node.js version in a child process.
+
+	@default process.execPath
+	*/
+	readonly execPath?: string;
+
+	/**
+	Buffer the output from the spawned process. When set to `false`, you must read the output of `stdout` and `stderr` (or `all` if the `all` option is `true`). Otherwise the returned promise will not be resolved/rejected.
+
+	If the spawned process fails, `error.stdout`, `error.stderr`, and `error.all` will contain the buffered data.
+
+	@default true
+	*/
+	readonly buffer?: boolean;
+
+	/**
+	Same options as [`stdio`](https://nodejs.org/dist/latest-v6.x/docs/api/child_process.html#child_process_options_stdio).
+
+	@default `inherit` with `$`, `pipe` otherwise
+	*/
+	readonly stdin?: StdioOption;
+
+	/**
+	Same options as [`stdio`](https://nodejs.org/dist/latest-v6.x/docs/api/child_process.html#child_process_options_stdio).
+
+	@default 'pipe'
+	*/
+	readonly stdout?: StdioOption;
+
+	/**
+	Same options as [`stdio`](https://nodejs.org/dist/latest-v6.x/docs/api/child_process.html#child_process_options_stdio).
+
+	@default 'pipe'
+	*/
+	readonly stderr?: StdioOption;
+
+	/**
+	Setting this to `false` resolves the promise with the error instead of rejecting it.
+
+	@default true
+	*/
+	readonly reject?: boolean;
+
+	/**
+	Add an `.all` property on the promise and the resolved value. The property contains the output of the process with `stdout` and `stderr` interleaved.
+
+	@default false
+	*/
+	readonly all?: boolean;
+
+	/**
+	Strip the final [newline character](https://en.wikipedia.org/wiki/Newline) from the output.
+
+	@default true
+	*/
+	readonly stripFinalNewline?: boolean;
+
+	/**
+	Set to `false` if you don't want to extend the environment variables when providing the `env` property.
+
+	@default true
+	*/
+	readonly extendEnv?: boolean;
+
+	/**
+	Current working directory of the child process.
+
+	@default process.cwd()
+	*/
+	readonly cwd?: string | URL;
+
+	/**
+	Environment key-value pairs. Extends automatically from `process.env`. Set `extendEnv` to `false` if you don't want this.
+
+	@default process.env
+	*/
+	readonly env?: NodeJS.ProcessEnv;
+
+	/**
+	Explicitly set the value of `argv[0]` sent to the child process. This will be set to `command` or `file` if not specified.
+	*/
+	readonly argv0?: string;
+
+	/**
+	Child's [stdio](https://nodejs.org/api/child_process.html#child_process_options_stdio) configuration.
+
+	@default 'pipe'
+	*/
+	readonly stdio?: 'pipe' | 'overlapped' | 'ignore' | 'inherit' | readonly StdioOption[];
+
+	/**
+	Specify the kind of serialization used for sending messages between processes when using the `stdio: 'ipc'` option or `execaNode()`:
+		- `json`: Uses `JSON.stringify()` and `JSON.parse()`.
+		- `advanced`: Uses [`v8.serialize()`](https://nodejs.org/api/v8.html#v8_v8_serialize_value)
+
+	[More info.](https://nodejs.org/api/child_process.html#child_process_advanced_serialization)
+
+	@default 'json'
+	*/
+	readonly serialization?: 'json' | 'advanced';
+
+	/**
+	Prepare child to run independently of its parent process. Specific behavior [depends on the platform](https://nodejs.org/api/child_process.html#child_process_options_detached).
+
+	@default false
+	*/
+	readonly detached?: boolean;
+
+	/**
+	Sets the user identity of the process.
+	*/
+	readonly uid?: number;
+
+	/**
+	Sets the group identity of the process.
+	*/
+	readonly gid?: number;
+
+	/**
+	If `true`, runs `command` inside of a shell. Uses `/bin/sh` on UNIX and `cmd.exe` on Windows. A different shell can be specified as a string. The shell should understand the `-c` switch on UNIX or `/d /s /c` on Windows.
 
 	We recommend against using this option since it is:
 	- not cross-platform, encouraging shell-specific syntax.
@@ -442,7 +852,7 @@ type CommonOptions<EncodingType extends EncodingOption = DefaultEncodingOption>
 	readonly verbose?: boolean;
 };
 
-type Options$1<EncodingType extends EncodingOption = DefaultEncodingOption> = {
+type Options<EncodingType extends EncodingOption = DefaultEncodingOption> = {
 	/**
 	Write some input to the `stdin` of your binary.
 
@@ -472,7 +882,7 @@ type NodeOptions<EncodingType extends EncodingOption = DefaultEncodingOption> =
 	@default process.execArgv
 	*/
 	readonly nodeOptions?: string[];
-} & Options$1<EncodingType>;
+} & Options<EncodingType>;
 
 type StdoutStderrAll = string | Buffer | undefined;
 
@@ -757,7 +1167,7 @@ declare abstract class JsPackageManager {
     /** Runs arbitrary package scripts. */
     abstract getRunCommand(command: string): string;
     /** Get the package.json file for a given module. */
-    abstract getModulePackageJSON(packageName: string): Promise<PackageJson | null>;
+    abstract getModulePackageJSON(packageName: string, cwd?: string): Promise<PackageJson | null>;
     isStorybookInMonorepo(): boolean;
     installDependencies(options?: {
         force?: boolean;
@@ -941,423 +1351,6 @@ declare class JsPackageManagerFactory {
     private static inferPackageManagerFromUserAgent;
 }
 
-declare function temporaryDirectory({ prefix }?: {
-    prefix?: string | undefined;
-}): Promise<string>;
-type FileOptions = MergeExclusive<{
-    /**
-     * File extension.
-     *
-     * Mutually exclusive with the `name` option.
-     *
-     * _You usually won't need this option. Specify it only when actually needed._
-     */
-    readonly extension?: string;
-}, {
-    /**
-     * Filename.
-     *
-     * Mutually exclusive with the `extension` option.
-     *
-     * _You usually won't need this option. Specify it only when actually needed._
-     */
-    readonly name?: string;
-}>;
-declare function temporaryFile({ name, extension }?: FileOptions): Promise<string>;
-declare function parseList(str: string): string[];
-/**
- * Given a package manager, returns the coerced version of Storybook. It tries to find renderer
- * packages in the project and returns the coerced version of the first one found. Example: If
- *
- * @storybook/react version 8.0.0-alpha.14 is installed, it returns the coerced version 8.0.0
- */
-declare function getCoercedStorybookVersion(packageManager: JsPackageManager): Promise<string>;
-declare function getEnvConfig(program: Record<string, any>, configEnv: Record<string, any>): void;
-/**
- * Given a file name, creates an object with utilities to manage a log file. It creates a temporary
- * log file which you can manage with the returned functions. You can then decide whether to move
- * the log file to the users project, or remove it.
- *
- * @example
- *
- * ```ts
- * const { logStream, moveLogFile, removeLogFile, clearLogFile, readLogFile } =
- *   await createLogStream('my-log-file.log');
- *
- * // SCENARIO 1:
- * // you can write custom messages to generate a log file
- * logStream.write('my log message');
- * await moveLogFile();
- *
- * // SCENARIO 2:
- * // or you can pass it to stdio and capture the output of that command
- * try {
- *   await executeCommand({
- *     command: 'pnpm',
- *     args: ['info', packageName, ...args],
- *     // do not output to the user, and send stdio and stderr to log file
- *     stdio: ['ignore', logStream, logStream],
- *   });
- * } catch (err) {
- *   // do something with the log file content
- *   const output = await readLogFile();
- *   // move the log file to the users project
- *   await moveLogFile();
- * }
- * // success, no need to keep the log file
- * await removeLogFile();
- * ```
- */
-declare const createLogStream: (logFileName?: string) => Promise<{
-    moveLogFile: () => Promise<void>;
-    removeLogFile: () => Promise<void>;
-    clearLogFile: () => Promise<void>;
-    readLogFile: () => Promise<string>;
-    logStream: WriteStream;
-}>;
-declare const isCorePackage: (pkg: string) => boolean;
-declare const isSatelliteAddon: (pkg: string) => boolean;
-
-interface Options {
-    before: CoreCommon_AddonInfo;
-    after: CoreCommon_AddonInfo;
-    configFile: string;
-    getConfig: (path: string) => any;
-}
-declare const checkAddonOrder: ({ before, after, configFile, getConfig }: Options) => Promise<void>;
-
-declare function loadEnvs(options?: {
-    production?: boolean;
-}): Promise<{
-    stringified: Record<string, string>;
-    raw: Record<string, string>;
-}>;
-declare const stringifyEnvs: (raw: Record<string, string>) => Record<string, string>;
-declare const stringifyProcessEnvs: (raw: Record<string, string>) => Record<string, string>;
-declare const optionalEnvToBoolean: (input: string | undefined) => boolean | undefined;
-/**
- * Consistently determine if we are in a CI environment
- *
- * Doing Boolean(process.env.CI) or !process.env.CI is not enough, because users might set CI=false
- * or CI=0, which would be truthy, and thus return true in those cases.
- */
-declare function isCI(): boolean | undefined;
-
-declare const commonGlobOptions: (glob: string) => {
-    ignore?: undefined;
-} | {
-    ignore: string[];
-};
-
-declare const frameworkToRenderer: Record<SupportedFramework | SupportedRenderer, SupportedRenderer>;
-declare const frameworkToBuilder: Record<SupportedFramework, SupportedBuilder>;
-
-/**
- * Builder options can be specified in `core.builder.options` or `framework.options.builder`.
- * Preference is given here to `framework.options.builder` if both are specified.
- */
-declare function getBuilderOptions<T extends Record<string, any>>(options: Options$2): Promise<T | Record<string, never>>;
-
-/** Framework can be a string or an object. This utility always returns the string name. */
-declare function getFrameworkName(options: Options$2): Promise<string>;
-/**
- * Extracts the proper framework name from the given framework field. The framework field can be the
- * framework package name or a path to the framework package.
- *
- * @example
- *
- * ```ts
- * extractFrameworkPackageName('/path/to/@storybook/angular'); // => '@storybook/angular'
- * extractFrameworkPackageName('@third-party/framework'); // => '@third-party/framework'
- * ```
- */
-declare const extractFrameworkPackageName: (framework: string) => string;
-
-/**
- * Render is set as a string on core. It must be set by the framework It falls back to the framework
- * name if not set
- */
-declare function getRendererName(options: Options$2): Promise<string>;
-/**
- * Extracts the proper renderer name from the given framework name.
- *
- * @example
- *
- * ```ts
- * extractRenderer('@storybook/react'); // => 'react'
- * extractRenderer('@storybook/angular'); // => 'angular'
- * extractRenderer('@third-party/framework'); // => null
- * ```
- *
- * @param frameworkName The name of the framework.
- * @returns The name of the renderer.
- */
-declare function extractRenderer(frameworkName: string): Promise<storybook_internal_types.SupportedRenderer | null>;
-
-declare function getStorybookConfiguration(storybookScript: string, shortName: string, longName: string): string | null;
-
-declare const rendererPackages: Record<string, SupportedRenderer>;
-declare const frameworkPackages: Record<string, SupportedFramework>;
-declare const builderPackages: Record<string, SupportedBuilder>;
-declare const compilerPackages: Record<string, CoreWebpackCompiler>;
-declare const findConfigFile: (prefix: string, configDir: string) => string | null;
-declare const getConfigInfo: (configDir?: string) => {
-    configDir: string;
-    mainConfigPath: string | null;
-    previewConfigPath: string | null;
-    managerConfigPath: string | null;
-};
-declare const getStorybookInfo: (configDir?: string, cwd?: string) => Promise<CoreCommon_StorybookInfo>;
-
-declare const getAutoRefs: (options: Options$2) => Promise<Record<string, Ref>>;
-declare function getRefs(options: Options$2): Promise<Record<string, Ref>>;
-
-declare function globToRegexp(glob: string): RegExp;
-
-declare class HandledError extends Error {
-    handled: boolean;
-    constructor(error: unknown);
-}
-
-/**
- * Return a string corresponding to template filled with bindings using following pattern: For each
- * (key, value) of `bindings` replace, in template, `{{key}}` by escaped version of `value`
- *
- * @param template {String} Template with `{{binding}}`
- * @param bindings {Object} key-value object use to fill the template, `{{key}}` will be replaced by
- *   `escaped(value)`
- * @returns {String} Filled template
- */
-declare const interpolate: (template: string, bindings: Record<string, string>) => string;
-
-interface PackageMeta {
-    name: string;
-    version: string;
-    [key: string]: any;
-}
-
-interface ToString {
-    toString(): string;
-}
-
-type StringOrToString = string | ToString;
-
-/**
- * Callback invoked when resolving asynchronously
- *
- * @param error
- * @param resolved Absolute path to resolved identifier
- */
-type resolveCallback = (err: Error | null, resolved?: string, pkg?: PackageMeta) => void;
-
-/**
- * Callback invoked when checking if a file or directory exists
- *
- * @param error
- * @param exists If the given file or directory exists
- */
-type existsCallback = (err: Error | null, isFile?: boolean) => void;
-
-/**
- * Callback invoked when reading a file
- *
- * @param error
- * @param isFile If the given file exists
- */
-type readFileCallback = (err: Error | null, file?: StringOrToString) => void;
-
-/**
- * Callback invoked when resolving a potential symlink
- *
- * @param error
- * @param resolved Absolute path to the resolved file
- */
-type realpathCallback = (err: Error | null, resolved?: string) => void;
-
-/**
- * Callback invoked when reading and parsing a package.json file
- *
- * @param error
- * @param resolved Absolute path to the resolved file
- */
-type readPackageCallback = (err: Error | null, package?: Record<string, unknown>) => void;
-
-/**
- * Synchronously resolve the module path string id, returning the result and throwing an error when id can't be resolved.
- *
- * @param id Identifier to resolve
- * @param options Options to use for resolving, optional.
- */
-declare function resolveSync(id: string, opts?: resolve.SyncOpts): string;
-
-/**
- * Return whether a package is in core
- */
-declare function resolveIsCore(id: string): boolean | undefined;
-
-// https://github.com/Microsoft/TypeScript/issues/3496#issuecomment-128553540
-type JSONValue = string | number | boolean | JSONObject | JSONArray;
-interface JSONObject {
-    [x: string]: JSONValue;
-}
-interface JSONArray extends Array<JSONValue> {}
-
-/**
- * Asynchronously resolve the module path string id into cb(err, res [, pkg]), where pkg (if defined) is the data from package.json
- *
- * @param id Identifier to resolve
- * @param callback
- */
-declare function resolve(id: string, cb: resolveCallback): void;
-
-/**
- * Asynchronously resolve the module path string id into cb(err, res [, pkg]), where pkg (if defined) is the data from package.json
- *
- * @param id Identifier to resolve
- * @param options Options to use for resolving, optional.
- * @param callback
- */
-declare function resolve(id: string, opts: resolve.AsyncOpts, cb: resolveCallback): void;
-
-declare namespace resolve {
-    export type PackageJSON = JSONObject;
-
-    interface Opts {
-        /** directory to begin resolving from (defaults to __dirname) */
-        basedir?: string | undefined;
-        /** package.json data applicable to the module being loaded */
-        package?: any;
-        /** set to false to exclude node core modules (e.g. fs) from the search */
-        includeCoreModules?: boolean | undefined;
-        /** array of file extensions to search in order (defaults to ['.js']) */
-        extensions?: string | readonly string[] | undefined;
-        /** transform the parsed package.json contents before looking at the "main" field */
-        packageFilter?: ((pkg: PackageJSON, pkgFile: string, dir: string) => PackageJSON) | undefined;
-        /** transform a path within a package */
-        pathFilter?: ((pkg: PackageJSON, path: string, relativePath: string) => string) | undefined;
-        /** require.paths array to use if nothing is found on the normal node_modules recursive walk (probably don't use this) */
-        paths?: string | readonly string[] | undefined;
-        /** return the list of candidate paths where the packages sources may be found (probably don't use this) */
-        packageIterator?:
-            | ((request: string, start: string, getPackageCandidates: () => string[], opts: Opts) => string[])
-            | undefined;
-        /** directory (or directories) in which to recursively look for modules. (default to 'node_modules') */
-        moduleDirectory?: string | readonly string[] | undefined;
-        /**
-         * if true, doesn't resolve `basedir` to real path before resolving.
-         * This is the way Node resolves dependencies when executed with the --preserve-symlinks flag.
-         *
-         * Note: this property is currently true by default but it will be changed to false in the next major version because Node's resolution
-         * algorithm does not preserve symlinks by default.
-         */
-        preserveSymlinks?: boolean | undefined;
-    }
-
-    interface BaseAsyncOpts extends Opts {
-        /** function to asynchronously test whether a file exists */
-        isFile?: ((file: string, cb: existsCallback) => void) | undefined;
-        /** function to asynchronously test whether a directory exists */
-        isDirectory?: ((directory: string, cb: existsCallback) => void) | undefined;
-        /** function to asynchronously resolve a potential symlink to its real path */
-        realpath?: ((file: string, cb: realpathCallback) => void) | undefined;
-    }
-
-    export type AsyncOpts =
-        & BaseAsyncOpts
-        & ({
-            /** how to read files asynchronously (defaults to fs.readFile) */
-            readFile?: ((file: string, cb: readFileCallback) => void) | undefined;
-            /** function to asynchronously read and parse a package.json file */
-            readPackage?: never | undefined;
-        } | {
-            /** how to read files asynchronously (defaults to fs.readFile) */
-            readFile?: never | undefined;
-            /** function to asynchronously read and parse a package.json file */
-            readPackage?:
-                | ((
-                    readFile: (file: string, cb: readFileCallback) => void,
-                    pkgfile: string,
-                    cb: readPackageCallback,
-                ) => void)
-                | undefined;
-        });
-
-    interface BaseSyncOpts extends Opts {
-        /** function to synchronously test whether a file exists */
-        isFile?: ((file: string) => boolean) | undefined;
-        /** function to synchronously test whether a directory exists */
-        isDirectory?: ((directory: string) => boolean) | undefined;
-        /** function to synchronously resolve a potential symlink to its real path */
-        realpathSync?: ((file: string) => string) | undefined;
-    }
-
-    export type SyncOpts =
-        & BaseSyncOpts
-        & ({
-            /** how to read files synchronously (defaults to fs.readFileSync) */
-            readFileSync?: ((file: string) => StringOrToString) | undefined;
-            /** function to synchronously read and parse a package.json file */
-            readPackageSync?: never | undefined;
-        } | {
-            /** how to read files synchronously (defaults to fs.readFileSync) */
-            readFileSync?: never | undefined;
-            /** function to synchronously read and parse a package.json file */
-            readPackageSync?:
-                | ((
-                    readFileSync: (file: string) => StringOrToString,
-                    pkgfile: string,
-                ) => Record<string, unknown> | undefined)
-                | undefined;
-        });
-
-    export var sync: typeof resolveSync;
-    export var isCore: typeof resolveIsCore;
-}
-
-declare const supportedExtensions: readonly [".js", ".ts", ".jsx", ".tsx", ".mjs", ".mts", ".mtsx", ".cjs", ".cts", ".ctsx"];
-declare function getInterpretedFile(pathToFile: string): string | undefined;
-declare function resolveImport(id: string, options: resolve.SyncOpts): string;
-
-declare function serverRequire(filePath: string | string[]): Promise<any> | null;
-
-declare function loadMainConfig({ configDir, cwd, skipCache, }: {
-    configDir: string;
-    cwd?: string;
-    skipCache?: boolean;
-}): Promise<StorybookConfig>;
-
-declare function loadManagerOrAddonsFile({ configDir }: {
-    configDir: string;
-}): string | undefined;
-
-declare function loadPreviewOrConfigFile({ configDir }: {
-    configDir: string;
-}): string | undefined;
-
-declare function logConfig(caption: unknown, config: unknown): void;
-
-declare const DEFAULT_FILES_PATTERN = "**/*.@(mdx|stories.@(js|jsx|mjs|ts|tsx))";
-declare const getDirectoryFromWorkingDir: ({ configDir, workingDir, directory, }: NormalizeOptions & {
-    directory: string;
-}) => string;
-declare const normalizeStoriesEntry: (entry: StoriesEntry, { configDir, workingDir, defaultFilesPattern }: NormalizeOptions) => NormalizedStoriesSpecifier;
-interface NormalizeOptions {
-    configDir: string;
-    workingDir: string;
-    defaultFilesPattern?: string;
-}
-declare const normalizeStories: (entries: StoriesEntry[], options: NormalizeOptions) => NormalizedStoriesSpecifier[];
-
-declare const getProjectRoot: () => string;
-declare const invalidateProjectRootCache: () => void;
-/** Finds files in the directory tree up to the project root */
-declare const findFilesUp: (matchers: string[], baseDir?: string) => string[];
-declare const nodePathsToArray: (nodePath: string) => string[];
-/** Ensures that a path starts with `./` or `../`, or is entirely `.` or `..` */
-declare function normalizeStoryPath(filename: string): string;
-
-declare function readTemplate(filename: string): Promise<string>;
-
 type RemoveAddonOptions = {
     packageManager: JsPackageManager;
     configDir?: string;
@@ -1589,4 +1582,4 @@ declare const getAddonNames: (mainConfig: StorybookConfig) => string[];
 declare const groupBy: <K extends PropertyKey, T>(items: T[], keySelector: (item: T, index: number) => K) => Record<K, T[]>;
 declare function invariant(condition: unknown, message?: string | (() => string)): asserts condition;
 
-export { DEFAULT_FILES_PATTERN, type ExecuteCommandOptions, type FileOptions, FileSystemCache, HandledError, type InstallationMetadata, type InterPresetOptions, JsPackageManager, JsPackageManagerFactory, type PackageJsonInfo, type PackageJsonWithDepsAndDevDeps, type PackageJsonWithMaybeDeps, PackageManagerName, type PackageMetadata, type RemoveAddonOptions, type SetupAddonInConfigOptions, builderPackages, cache, checkAddonOrder, commonGlobOptions, compilerPackages, createFileSystemCache, createLogStream, doesVariableOrFunctionDeclarationExist, executeCommand, executeCommandSync, executeNodeCommand, extractFrameworkPackageName, extractRenderer, filterPresetsConfig, findConfigFile, findFilesUp, formatFileContent, frameworkPackages, frameworkToBuilder, frameworkToRenderer, getAbsolutePathWrapperAsCallExpression, getAbsolutePathWrapperName, getAddonNames, getAutoRefs, getBuilderOptions, getCoercedStorybookVersion, getConfigInfo, getDirectoryFromWorkingDir, getEnvConfig, getFieldsForGetAbsolutePathWrapper, getFrameworkName, getInterpretedFile, getPackageDetails, getPresets, getPrettier, getPreviewBodyTemplate, getPreviewHeadTemplate, getProjectRoot, getRefs, getRendererName, getStoryId, getStoryTitle, getStorybookConfiguration, getStorybookInfo, globToRegexp, groupBy, importMetaResolve, importModule, interpolate, invalidateProjectRootCache, invariant, isCI, isCorePackage, isGetAbsolutePathWrapperNecessary, isPreservingSymlinks, isSatelliteAddon, loadAllPresets, loadEnvs, loadMainConfig, loadManagerOrAddonsFile, loadPreset, loadPreviewOrConfigFile, logConfig, nodePathsToArray, normalizeStories, normalizeStoriesEntry, normalizeStoryPath, optionalEnvToBoolean, parseList, posix, readTemplate, removeAddon, rendererPackages, resolveAddonName, resolveImport, resolvePackageDir, resolvePathInStorybookCache, safeResolveModule, satisfies, scanAndTransformFiles, serverRequire, setupAddonInConfig, stringifyEnvs, stringifyProcessEnvs, supportedExtensions, syncPreviewAddonsWithMainConfig, syncStorybookAddons, temporaryDirectory, temporaryFile, transformImportFiles, validateConfigurationFiles, validateFrameworkName, _default as versions, wrapValueWithGetAbsolutePathWrapper };
+export { DEFAULT_FILES_PATTERN, type ExecuteCommandOptions, type FileOptions, FileSystemCache, HandledError, type InstallationMetadata, type InterPresetOptions, JsPackageManager, JsPackageManagerFactory, type PackageJsonInfo, type PackageJsonWithDepsAndDevDeps, type PackageJsonWithMaybeDeps, PackageManagerName, type PackageMetadata, type RemoveAddonOptions, type SetupAddonInConfigOptions, builderPackages, cache, checkAddonOrder, commonGlobOptions, compilerPackages, createFileSystemCache, createLogStream, doesVariableOrFunctionDeclarationExist, executeCommand, executeCommandSync, executeNodeCommand, extractFrameworkPackageName, extractRenderer, filterPresetsConfig, findConfigFile, findFilesUp, formatFileContent, frameworkPackages, frameworkToBuilder, frameworkToRenderer, getAbsolutePathWrapperAsCallExpression, getAbsolutePathWrapperName, getAddonNames, getAutoRefs, getBuilderOptions, getConfigInfo, getDirectoryFromWorkingDir, getEnvConfig, getFieldsForGetAbsolutePathWrapper, getFrameworkName, getInterpretedFile, getPackageDetails, getPresets, getPrettier, getPreviewBodyTemplate, getPreviewHeadTemplate, getProjectRoot, getRefs, getRendererName, getStoryId, getStoryTitle, getStorybookConfiguration, getStorybookInfo, globToRegexp, groupBy, importMetaResolve, importModule, interpolate, invalidateProjectRootCache, invariant, isCI, isCorePackage, isGetAbsolutePathWrapperNecessary, isPreservingSymlinks, isSatelliteAddon, loadAllPresets, loadEnvs, loadMainConfig, loadManagerOrAddonsFile, loadPreset, loadPreviewOrConfigFile, logConfig, nodePathsToArray, normalizeStories, normalizeStoriesEntry, normalizeStoryPath, optionalEnvToBoolean, parseList, posix, readTemplate, removeAddon, rendererPackages, resolveAddonName, resolveImport, resolvePackageDir, resolvePathInStorybookCache, safeResolveModule, satisfies, scanAndTransformFiles, serverRequire, setupAddonInConfig, stringifyEnvs, stringifyProcessEnvs, supportedExtensions, syncPreviewAddonsWithMainConfig, syncStorybookAddons, temporaryDirectory, temporaryFile, transformImportFiles, validateConfigurationFiles, validateFrameworkName, _default as versions, wrapValueWithGetAbsolutePathWrapper };