bun-workspaces 1.0.1-alpha → 1.0.1

package/src/runScript/runScript.mjs

@@ -0,0 +1,89 @@
+import {
+  createMultiProcessOutput,
+  createProcessOutput,
+} from "./output/index.mjs";
+import { createScriptExecutor } from "./scriptExecution.mjs";
+import { createSubprocess } from "./subprocesses.mjs"; // CONCATENATED MODULE: external "./output/index.mjs"
+// CONCATENATED MODULE: external "./scriptExecution.mjs"
+// CONCATENATED MODULE: external "./subprocesses.mjs"
+// CONCATENATED MODULE: ./src/runScript/runScript.ts
+
+const SIGNAL_MAP = {
+  130: "SIGINT",
+  143: "SIGTERM",
+  129: "SIGHUP",
+  131: "SIGQUIT",
+  138: "SIGUSR1",
+  140: "SIGUSR2",
+};
+/**
+ * Run some script and get an async output stream of
+ * stdout and stderr chunks and a result object
+ * containing exit details.
+ */ const runScript = ({
+  scriptCommand,
+  metadata,
+  env,
+  shell = "system",
+  ignoreOutput = false,
+}) => {
+  const startTime = new Date();
+  const { argv, cleanup } = createScriptExecutor(scriptCommand.command, shell);
+  const proc = createSubprocess(argv, {
+    cwd: scriptCommand.workingDirectory || process.cwd(),
+    env: {
+      ...process.env,
+      ...env,
+      _BW_SCRIPT_SHELL_OPTION: shell,
+      FORCE_COLOR: "1",
+    },
+    stdout: ignoreOutput ? "ignore" : "pipe",
+    stderr: ignoreOutput ? "ignore" : "pipe",
+    stdin: "ignore",
+  });
+  proc.exited.finally(cleanup);
+  const processOutput = createMultiProcessOutput([
+    createProcessOutput(
+      proc.stdout
+        ? proc.stdout
+        : (async function* () {
+            /* empty */
+          })(),
+      {
+        ...metadata,
+        streamName: "stdout",
+      },
+    ),
+    createProcessOutput(
+      proc.stderr
+        ? proc.stderr
+        : (async function* () {
+            /* empty */
+          })(),
+      {
+        ...metadata,
+        streamName: "stderr",
+      },
+    ),
+  ]);
+  const exit = proc.exited.then((exitCode) => {
+    const endTime = new Date();
+    return {
+      exitCode,
+      signal: proc.signalCode ?? SIGNAL_MAP[exitCode] ?? null,
+      success: exitCode === 0,
+      startTimeISO: startTime.toISOString(),
+      endTimeISO: endTime.toISOString(),
+      durationMs: endTime.getTime() - startTime.getTime(),
+      metadata,
+    };
+  });
+  return {
+    output: processOutput,
+    exit,
+    metadata,
+    kill: (exit) => proc.kill(exit),
+  };
+};
+
+export { runScript };

package/src/runScript/runScripts.d.ts

@@ -0,0 +1,65 @@
+import { type MultiProcessOutput, type OutputStreamName } from "./output";
+import { type ParallelMaxValue } from "./parallel";
+import { type RunScriptExit, type RunScriptResult } from "./runScript";
+import { type ScriptCommand } from "./scriptCommand";
+import { type ScriptShellOption } from "./scriptShellOption";
+export type RunScriptsScript<ScriptMetadata extends object = object> = {
+  scriptCommand: ScriptCommand;
+  metadata: ScriptMetadata;
+  env: Record<string, string>;
+  /** The shell to use to run the script */
+  shell?: ScriptShellOption;
+  /** Indices of other scripts in the array that must complete before this one starts */
+  dependsOn?: number[];
+  /** Set to `true` to ignore all output from the script. This saves memory when you don't need script output. */
+  ignoreOutput?: boolean;
+};
+export type RunScriptsScriptResult<ScriptMetadata extends object = object> = {
+  /** The result of running the script */
+  result: RunScriptResult<ScriptMetadata>;
+};
+export type RunScriptsSummary<ScriptMetadata extends object = object> = {
+  totalCount: number;
+  successCount: number;
+  failureCount: number;
+  allSuccess: boolean;
+  startTimeISO: string;
+  endTimeISO: string;
+  durationMs: number;
+  scriptResults: RunScriptExit<ScriptMetadata>[];
+};
+export type ScriptEventName = "start" | "skip" | "exit";
+export type RunScriptsResult<ScriptMetadata extends object = object> = {
+  output: MultiProcessOutput<
+    ScriptMetadata & {
+      streamName: OutputStreamName;
+    }
+  >;
+  /** Resolves with a results summary after all scripts have exited */
+  summary: Promise<RunScriptsSummary<ScriptMetadata>>;
+};
+export type RunScriptsParallelOptions = {
+  max: ParallelMaxValue;
+};
+export type RunScriptsOptions<ScriptMetadata extends object = object> = {
+  scripts: RunScriptsScript<ScriptMetadata>[];
+  parallel: boolean | RunScriptsParallelOptions;
+  /** When true, run scripts even if a dependency failed. Default: false (skip them). */
+  ignoreDependencyFailure?: boolean;
+  /** Set to `true` to ignore all output from the scripts. This saves memory when you don't need script output. */
+  ignoreOutput?: boolean;
+  /** Callback to invoke when a script event occurs */
+  onScriptEvent?: (
+    event: ScriptEventName,
+    scriptIndex: number,
+    result: RunScriptExit<ScriptMetadata> | null,
+  ) => void;
+};
+/** Run a list of scripts */
+export declare const runScripts: <ScriptMetadata extends object = object>({
+  scripts,
+  parallel,
+  ignoreDependencyFailure,
+  ignoreOutput,
+  onScriptEvent,
+}: RunScriptsOptions<ScriptMetadata>) => RunScriptsResult<ScriptMetadata>;

package/src/runScript/runScripts.mjs

@@ -0,0 +1,263 @@
+import { createAsyncIterableQueue } from "../internal/core/index.mjs";
+import { logger } from "../internal/logger/index.mjs";
+import {
+  createMultiProcessOutput,
+  createProcessOutput,
+} from "./output/index.mjs";
+import { determineParallelMax } from "./parallel.mjs";
+import { runScript } from "./runScript.mjs"; // CONCATENATED MODULE: external "../internal/core/index.mjs"
+// CONCATENATED MODULE: external "../internal/logger/index.mjs"
+// CONCATENATED MODULE: external "./output/index.mjs"
+// CONCATENATED MODULE: external "./parallel.mjs"
+// CONCATENATED MODULE: external "./runScript.mjs"
+// CONCATENATED MODULE: ./src/runScript/runScripts.ts
+
+/** Validate dependency indices and detect cycles via DFS */ const validateScriptDependencies =
+  (scripts) => {
+    const scriptCount = scripts.length;
+    for (let i = 0; i < scriptCount; i++) {
+      const deps = scripts[i].dependsOn;
+      if (!deps) continue;
+      for (const dep of deps) {
+        if (dep === i) {
+          throw new Error(
+            `Script at index ${i} has a self-referencing dependency`,
+          );
+        }
+        if (dep < 0 || dep >= scriptCount) {
+          throw new Error(
+            `Script at index ${i} depends on invalid index ${dep} (valid range: 0-${scriptCount - 1})`,
+          );
+        }
+      }
+    }
+    const WHITE = 0;
+    const GRAY = 1;
+    const BLACK = 2;
+    const colors = new Array(scriptCount).fill(WHITE);
+    const visit = (node, path) => {
+      colors[node] = GRAY;
+      const deps = scripts[node].dependsOn;
+      if (deps) {
+        for (const dep of deps) {
+          if (colors[dep] === GRAY) {
+            const cycleStart = path.indexOf(dep);
+            const cycle = path.slice(cycleStart);
+            throw new Error(
+              `Dependency cycle detected: ${[...cycle, dep].join(" -> ")}`,
+            );
+          }
+          if (colors[dep] === WHITE) {
+            visit(dep, [...path, dep]);
+          }
+        }
+      }
+      colors[node] = BLACK;
+    };
+    for (let i = 0; i < scriptCount; i++) {
+      if (colors[i] === WHITE) {
+        visit(i, [i]);
+      }
+    }
+  };
+/** Run a list of scripts */ const runScripts = ({
+  scripts,
+  parallel,
+  ignoreDependencyFailure = false,
+  ignoreOutput = false,
+  onScriptEvent,
+}) => {
+  validateScriptDependencies(scripts);
+  const startTime = new Date();
+  const scriptTriggers = scripts.map((_, index) => {
+    let trigger = () => {
+      void 0;
+    };
+    const promise = new Promise((res) => {
+      trigger = () => res(result);
+    });
+    const result = {
+      promise,
+      trigger,
+      index,
+    };
+    return result;
+  });
+  const scriptResults = scripts.map(() => null);
+  const parallelMax =
+    parallel === false
+      ? 1
+      : determineParallelMax(
+          typeof parallel === "boolean" ? "default" : parallel.max,
+        );
+  const parallelBatchSize = Math.min(parallelMax, scripts.length);
+  const recommendedParallelMax = determineParallelMax("auto");
+  if (
+    parallel &&
+    parallelBatchSize > recommendedParallelMax &&
+    process.env._BW_IS_INTERNAL_TEST !== "true"
+  ) {
+    logger.warn(
+      `Number of scripts to run in parallel (${parallelBatchSize}) is greater than the available CPUs (${recommendedParallelMax})`,
+    );
+  }
+  const pendingScripts = new Set(scripts.map((_, i) => i));
+  const runningScripts = new Set();
+  const completedScripts = new Set();
+  const exitResults = scripts.map(() => null);
+  const scriptProcessBytes = scripts.map(() => null);
+  const createSkippedExit = (index) => {
+    const now = new Date().toISOString();
+    return {
+      exitCode: -1,
+      signal: null,
+      success: false,
+      skipped: true,
+      startTimeISO: now,
+      endTimeISO: now,
+      durationMs: 0,
+      metadata: scripts[index].metadata,
+    };
+  };
+  const createSkippedResult = (index) => {
+    const skippedExit = createSkippedExit(index);
+    exitResults[index] = skippedExit;
+    return {
+      result: {
+        output: createMultiProcessOutput([]),
+        exit: Promise.resolve(skippedExit),
+        metadata: scripts[index].metadata,
+        kill: () => {
+          /* empty */
+        },
+      },
+    };
+  };
+  const hasDependencyFailure = (index) => {
+    const deps = scripts[index].dependsOn;
+    if (!deps) return false;
+    return deps.some(
+      (dep) => exitResults[dep] !== null && !exitResults[dep].success,
+    );
+  };
+  const areDependenciesMet = (index) => {
+    const deps = scripts[index].dependsOn;
+    if (!deps) return true;
+    return deps.every((dep) => completedScripts.has(dep));
+  };
+  const scriptOutputQueues = scripts.map(() => ({
+    stdout: createAsyncIterableQueue(),
+    stderr: createAsyncIterableQueue(),
+  }));
+  const scheduleReadyScripts = () => {
+    let changed = true;
+    while (changed) {
+      changed = false;
+      for (const index of [...pendingScripts]) {
+        if (runningScripts.size >= parallelMax) return;
+        if (!areDependenciesMet(index)) continue;
+        if (!ignoreDependencyFailure && hasDependencyFailure(index)) {
+          pendingScripts.delete(index);
+          completedScripts.add(index);
+          scriptResults[index] = createSkippedResult(index);
+          scriptProcessBytes[index] = (async function* () {
+            /* empty */
+          })();
+          scriptOutputQueues[index].stdout.close();
+          scriptOutputQueues[index].stderr.close();
+          onScriptEvent?.("skip", index, null);
+          scriptTriggers[index].trigger();
+          changed = true;
+          continue;
+        }
+        pendingScripts.delete(index);
+        runningScripts.add(index);
+        const scriptResult = {
+          ...scripts[index],
+          result: runScript({
+            ...scripts[index],
+            env: {
+              ...scripts[index].env,
+              _BW_PARALLEL_MAX: parallelMax.toString(),
+            },
+            ignoreOutput,
+          }),
+        };
+        scriptResults[index] = scriptResult;
+        const bytesOutput = scriptResult.result.output.bytes();
+        scriptProcessBytes[index] = bytesOutput;
+        (async () => {
+          for await (const { chunk, metadata } of bytesOutput) {
+            scriptOutputQueues[index][metadata.streamName].push(chunk);
+          }
+          scriptOutputQueues[index].stdout.close();
+          scriptOutputQueues[index].stderr.close();
+        })();
+        onScriptEvent?.("start", index, null);
+        scriptTriggers[index].trigger();
+        scriptResult.result.exit.then((exit) => {
+          runningScripts.delete(index);
+          completedScripts.add(index);
+          exitResults[index] = exit;
+          onScriptEvent?.("exit", index, exit);
+          scheduleReadyScripts();
+        });
+      }
+    }
+  };
+  const multiProcessOutput = createMultiProcessOutput(
+    scriptOutputQueues.flatMap(({ stdout, stderr }, index) => [
+      createProcessOutput(stdout, {
+        ...scripts[index].metadata,
+        streamName: "stdout",
+      }),
+      createProcessOutput(stderr, {
+        ...scripts[index].metadata,
+        streamName: "stderr",
+      }),
+    ]),
+  );
+  const handleScriptProcesses = async () => {
+    let pendingScriptCount = scripts.length;
+    while (pendingScriptCount > 0) {
+      const { index } = await Promise.race(
+        scriptTriggers.map((trigger) => trigger.promise),
+      );
+      pendingScriptCount--;
+      scriptTriggers[index].promise = new Promise(() => {
+        void 0;
+      });
+    }
+    await Promise.all(
+      scriptOutputQueues.flatMap(({ stdout, stderr }) => [
+        stdout.closed,
+        stderr.closed,
+      ]),
+    );
+    await Promise.all(scriptResults.map(({ result }) => result.exit));
+  };
+  const awaitSummary = async () => {
+    scheduleReadyScripts();
+    await handleScriptProcesses();
+    const scriptExitResults = await Promise.all(
+      scripts.map((_, index) => scriptResults[index].result.exit),
+    );
+    const endTime = new Date();
+    return {
+      totalCount: scriptExitResults.length,
+      successCount: scriptExitResults.filter((exit) => exit.success).length,
+      failureCount: scriptExitResults.filter((exit) => !exit.success).length,
+      allSuccess: scriptExitResults.every((exit) => exit.success),
+      startTimeISO: startTime.toISOString(),
+      endTimeISO: endTime.toISOString(),
+      durationMs: endTime.getTime() - startTime.getTime(),
+      scriptResults: scriptExitResults,
+    };
+  };
+  return {
+    output: multiProcessOutput,
+    summary: awaitSummary(),
+  };
+};
+
+export { runScripts };

package/src/runScript/scriptCommand.d.ts

@@ -0,0 +1,33 @@
+import type { Workspace } from "../workspaces";
+export declare const WORKSPACE_SCRIPT_COMMAND_METHODS: readonly [
+  "cd",
+  "filter",
+];
+export type WorkspaceScriptCommandMethod =
+  (typeof WORKSPACE_SCRIPT_COMMAND_METHODS)[number];
+/** Basic metadata to run a script, the command string and the directory to run it in */
+export interface ScriptCommand {
+  /** The command string to run */
+  command: string;
+  /** The directory to run the command in */
+  workingDirectory: string;
+}
+export interface CreateWorkspaceScriptCommandOptions {
+  /**
+   * The method to use to run the script.
+   * Either run in the workspace directory or use bun's --filter option.
+   * Defaults to "cd".
+   */
+  method?: WorkspaceScriptCommandMethod;
+  /** The name of the script to run */
+  scriptName: string;
+  /** The arguments to append to the command */
+  args: string;
+  /** The workspace that the script belongs to */
+  workspace: Workspace;
+  /** The root directory of the project */
+  rootDirectory: string;
+}
+export declare const createWorkspaceScriptCommand: (
+  options: CreateWorkspaceScriptCommandOptions,
+) => ScriptCommand;

package/src/runScript/scriptCommand.mjs

@@ -0,0 +1,19 @@
+import path from "path"; // CONCATENATED MODULE: external "path"
+// CONCATENATED MODULE: ./src/runScript/scriptCommand.ts
+
+const WORKSPACE_SCRIPT_COMMAND_METHODS = ["cd", "filter"];
+const spaceArgs = (args) => (args ? ` ${args.trim()}` : "");
+const METHODS = {
+  cd: ({ scriptName, workspace, rootDirectory, args }) => ({
+    workingDirectory: path.resolve(rootDirectory, workspace.path),
+    command: `bun --silent run ${scriptName}${spaceArgs(args)}`,
+  }),
+  filter: ({ scriptName, workspace, args, rootDirectory }) => ({
+    workingDirectory: rootDirectory,
+    command: `bun --silent run --filter=${JSON.stringify(workspace.name)} ${scriptName}${spaceArgs(args)}`,
+  }),
+};
+const createWorkspaceScriptCommand = (options) =>
+  METHODS[options.method ?? "cd"](options);
+
+export { WORKSPACE_SCRIPT_COMMAND_METHODS, createWorkspaceScriptCommand };

package/src/runScript/scriptExecution.d.ts

@@ -0,0 +1,9 @@
+import { type ScriptShellOption } from "./scriptShellOption";
+export type ScriptExecutor = {
+  argv: string[];
+  cleanup: () => void;
+};
+export declare const createScriptExecutor: (
+  command: string,
+  shell: ScriptShellOption,
+) => ScriptExecutor;

package/src/runScript/scriptExecution.mjs

@@ -0,0 +1,50 @@
+import {
+  BunWorkspacesError,
+  DEFAULT_TEMP_DIR,
+  IS_WINDOWS,
+  createShortId,
+} from "../internal/core/index.mjs";
+import { resolveScriptShell } from "./scriptShellOption.mjs"; // CONCATENATED MODULE: external "../internal/core/index.mjs"
+// CONCATENATED MODULE: external "./scriptShellOption.mjs"
+// CONCATENATED MODULE: ./src/runScript/scriptExecution.ts
+
+const createWindowsBatchFile = (command) => {
+  const fileName = `${createShortId(6)}.cmd`;
+  const fileContent = `@echo off\r\n${command}\r\n`;
+  return DEFAULT_TEMP_DIR.createFile({
+    name: fileName,
+    content: fileContent,
+  });
+};
+const createShellScript = (command) => {
+  const fileName = `${createShortId(6)}.sh`;
+  return DEFAULT_TEMP_DIR.createFile({
+    name: fileName,
+    content: command,
+    mode: 493,
+  });
+};
+const createScriptExecutor = (command, shell) => {
+  shell = resolveScriptShell(shell);
+  if (shell === "bun") {
+    const { filePath, cleanup } = createShellScript(command);
+    return {
+      argv: ["bun", filePath],
+      cleanup,
+    };
+  }
+  if (shell === "system") {
+    const { filePath, cleanup } = IS_WINDOWS
+      ? createWindowsBatchFile(command)
+      : createShellScript(command);
+    return {
+      argv: IS_WINDOWS
+        ? ["cmd", "/d", "/s", "/c", "call", filePath]
+        : ["sh", "-c", filePath],
+      cleanup,
+    };
+  }
+  throw new BunWorkspacesError(`Invalid shell option: ${shell}`);
+};
+
+export { createScriptExecutor };

package/src/runScript/scriptRuntimeMetadata.d.ts

@@ -0,0 +1,73 @@
+import type { ScriptShellOption } from "./scriptShellOption";
+export interface ScriptRuntimeMetadata {
+  projectPath: string;
+  projectName: string;
+  workspacePath: string;
+  workspaceRelativePath: string;
+  workspaceName: string;
+  scriptName: string;
+}
+declare const SCRIPT_RUNTIME_METADATA_CONFIG: {
+  readonly projectPath: {
+    readonly inlineName: "<projectPath>";
+    readonly envVarName: "BW_PROJECT_PATH";
+  };
+  readonly projectName: {
+    readonly inlineName: "<projectName>";
+    readonly envVarName: "BW_PROJECT_NAME";
+  };
+  readonly workspacePath: {
+    readonly inlineName: "<workspacePath>";
+    readonly envVarName: "BW_WORKSPACE_PATH";
+  };
+  readonly workspaceRelativePath: {
+    readonly inlineName: "<workspaceRelativePath>";
+    readonly envVarName: "BW_WORKSPACE_RELATIVE_PATH";
+  };
+  readonly scriptName: {
+    readonly inlineName: "<scriptName>";
+    readonly envVarName: "BW_SCRIPT_NAME";
+  };
+  readonly workspaceName: {
+    readonly inlineName: "<workspaceName>";
+    readonly envVarName: "BW_WORKSPACE_NAME";
+  };
+};
+export type ScriptRuntimeMetadataKey =
+  keyof typeof SCRIPT_RUNTIME_METADATA_CONFIG;
+export declare const getScriptRuntimeMetadataConfig: (
+  key: ScriptRuntimeMetadataKey,
+) =>
+  | {
+      readonly inlineName: "<projectPath>";
+      readonly envVarName: "BW_PROJECT_PATH";
+    }
+  | {
+      readonly inlineName: "<projectName>";
+      readonly envVarName: "BW_PROJECT_NAME";
+    }
+  | {
+      readonly inlineName: "<workspacePath>";
+      readonly envVarName: "BW_WORKSPACE_PATH";
+    }
+  | {
+      readonly inlineName: "<workspaceRelativePath>";
+      readonly envVarName: "BW_WORKSPACE_RELATIVE_PATH";
+    }
+  | {
+      readonly inlineName: "<scriptName>";
+      readonly envVarName: "BW_SCRIPT_NAME";
+    }
+  | {
+      readonly inlineName: "<workspaceName>";
+      readonly envVarName: "BW_WORKSPACE_NAME";
+    };
+export declare const createScriptRuntimeEnvVars: (
+  metadata: ScriptRuntimeMetadata,
+) => Record<string, string>;
+export declare const interpolateScriptRuntimeMetadata: (
+  text: string,
+  metadata: ScriptRuntimeMetadata,
+  shell: ScriptShellOption,
+) => string;
+export {};

package/src/runScript/scriptRuntimeMetadata.mjs

@@ -0,0 +1,61 @@
+import { IS_WINDOWS } from "../internal/core/index.mjs"; // CONCATENATED MODULE: external "../internal/core/index.mjs"
+// CONCATENATED MODULE: ./src/runScript/scriptRuntimeMetadata.ts
+
+const SCRIPT_RUNTIME_METADATA_CONFIG = {
+  projectPath: {
+    inlineName: "<projectPath>",
+    envVarName: "BW_PROJECT_PATH",
+  },
+  projectName: {
+    inlineName: "<projectName>",
+    envVarName: "BW_PROJECT_NAME",
+  },
+  workspacePath: {
+    inlineName: "<workspacePath>",
+    envVarName: "BW_WORKSPACE_PATH",
+  },
+  workspaceRelativePath: {
+    inlineName: "<workspaceRelativePath>",
+    envVarName: "BW_WORKSPACE_RELATIVE_PATH",
+  },
+  scriptName: {
+    inlineName: "<scriptName>",
+    envVarName: "BW_SCRIPT_NAME",
+  },
+  workspaceName: {
+    inlineName: "<workspaceName>",
+    envVarName: "BW_WORKSPACE_NAME",
+  },
+};
+const getScriptRuntimeMetadataConfig = (key) =>
+  SCRIPT_RUNTIME_METADATA_CONFIG[key];
+const createScriptRuntimeEnvVars = (metadata) =>
+  Object.entries(SCRIPT_RUNTIME_METADATA_CONFIG).reduce((acc, [key, value]) => {
+    acc[value.envVarName] = metadata[key];
+    return acc;
+  }, {});
+const interpolateScriptRuntimeMetadata = (text, metadata, shell) =>
+  text.replace(
+    new RegExp(
+      Object.values(SCRIPT_RUNTIME_METADATA_CONFIG)
+        .flatMap((value) => value.inlineName)
+        .join("|"),
+      "g",
+    ),
+    (match) => {
+      const key = Object.entries(SCRIPT_RUNTIME_METADATA_CONFIG).find(
+        ([_, value]) => value.inlineName === match,
+      )?.[0];
+      const value = metadata[key];
+      if (IS_WINDOWS && shell === "bun") {
+        return value.replace(/\\/g, "\\\\");
+      }
+      return value;
+    },
+  );
+
+export {
+  createScriptRuntimeEnvVars,
+  getScriptRuntimeMetadataConfig,
+  interpolateScriptRuntimeMetadata,
+};

package/src/runScript/scriptShellOption.d.ts

@@ -0,0 +1,8 @@
+export declare const SCRIPT_SHELL_OPTIONS: readonly ["bun", "system"];
+export type ScriptShellOption = (typeof SCRIPT_SHELL_OPTIONS)[number];
+export declare const validateScriptShellOption: (
+  shell: string,
+  fromEnvVar?: boolean,
+) => ScriptShellOption;
+export declare const getScriptShellDefault: () => "bun" | "system";
+export declare const resolveScriptShell: (shell?: string) => ScriptShellOption;