bun-workspaces 1.0.1-alpha → 1.0.1

package/src/internal/core/runtime/onExit.mjs

@@ -0,0 +1,54 @@
+import { logger } from "../../logger/index.mjs"; // CONCATENATED MODULE: external "../../logger/index.mjs"
+// CONCATENATED MODULE: ./src/internal/core/runtime/onExit.ts
+
+let handlers = [];
+let listenersRegistered = false;
+const runAllHandlers = (exit) => {
+  for (const handler of handlers) {
+    try {
+      handler(exit);
+    } catch (error) {
+      logger.error("Error running exit handler");
+      logger.error(error);
+    }
+  }
+  logger.debug("Exit handlers ran");
+  handlers = [];
+};
+const registerListeners = () => {
+  if (listenersRegistered) return;
+  listenersRegistered = true;
+  logger.debug("Registering exit listeners");
+  process.on("exit", (code) => {
+    runAllHandlers(code);
+    process.exit(code);
+  });
+  for (const signal of [
+    "SIGINT",
+    "SIGTERM",
+    "SIGUSR1",
+    "SIGUSR2",
+    "SIGHUP",
+    "SIGQUIT",
+  ]) {
+    const handleSignal = () => {
+      runAllHandlers(signal);
+      process.off(signal, handleSignal);
+      process.kill(process.pid, signal);
+    };
+    process.on(signal, handleSignal);
+  }
+};
+const runOnExit = (fn) => {
+  registerListeners();
+  let ran = false;
+  const wrapped = (exit) => {
+    if (ran) return;
+    ran = true;
+    fn(exit);
+    handlers = handlers.filter((handler) => handler !== wrapped);
+  };
+  handlers.push(wrapped);
+};
+
+export { runOnExit };

package/src/internal/core/runtime/os.d.ts

@@ -0,0 +1,4 @@
+export declare const IS_WINDOWS: boolean;
+export declare const IS_MACOS: boolean;
+export declare const IS_LINUX: boolean;
+export declare const IS_UNIX: boolean;

package/src/internal/core/runtime/os.mjs

@@ -0,0 +1,7 @@
+// CONCATENATED MODULE: ./src/internal/core/runtime/os.ts
+const IS_WINDOWS = process.platform === "win32";
+const IS_MACOS = process.platform === "darwin";
+const IS_LINUX = process.platform === "linux";
+const IS_UNIX = IS_MACOS || IS_LINUX;
+
+export { IS_LINUX, IS_MACOS, IS_UNIX, IS_WINDOWS };

package/src/internal/core/runtime/tempFile.d.ts

@@ -0,0 +1,20 @@
+import fs from "fs";
+export type CreateTempFileOptions = {
+  name: string;
+  content: string;
+  mode?: fs.Mode;
+};
+declare class TempDir {
+  readonly id: string;
+  readonly dir: string;
+  constructor();
+  initialize(clean?: boolean): void;
+  createFilePath(fileName: string): string;
+  createFile({ name, content, mode }: CreateTempFileOptions): {
+    filePath: string;
+    cleanup: () => void;
+  };
+  cleanup(): void;
+}
+export declare let DEFAULT_TEMP_DIR: TempDir;
+export {};

package/src/internal/core/runtime/tempFile.mjs

@@ -0,0 +1,87 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { validateCurrentBunVersion } from "../../bun/bunVersion.mjs";
+import { logger } from "../../logger/index.mjs";
+import { BUN_WORKSPACES_VERSION } from "../../version.mjs";
+import { createShortId } from "../language/string/id.mjs";
+import { runOnExit } from "./onExit.mjs"; // CONCATENATED MODULE: external "fs"
+// CONCATENATED MODULE: external "os"
+// CONCATENATED MODULE: external "path"
+// CONCATENATED MODULE: external "../../bun/bunVersion.mjs"
+// CONCATENATED MODULE: external "../../logger/index.mjs"
+// CONCATENATED MODULE: external "../../version.mjs"
+// CONCATENATED MODULE: external "../language/string/id.mjs"
+// CONCATENATED MODULE: external "./onExit.mjs"
+// CONCATENATED MODULE: ./src/internal/core/runtime/tempFile.ts
+
+const getTempBasePackageDir = () => path.join(os.tmpdir(), "bun-workspaces");
+const getTempParentDir = () =>
+  path.join(getTempBasePackageDir(), BUN_WORKSPACES_VERSION);
+class TempDir {
+  id = createShortId(6);
+  dir;
+  constructor() {
+    this.dir = path.join(getTempParentDir(), this.id);
+  }
+  initialize(clean = false) {
+    if (fs.existsSync(this.dir)) return;
+    fs.mkdirSync(this.dir, {
+      recursive: true,
+    });
+    fs.chmodSync(this.dir, 448);
+    if (clean) {
+      for (const dir of fs.readdirSync(path.resolve(getTempBasePackageDir()))) {
+        if (dir !== BUN_WORKSPACES_VERSION) {
+          logger.debug(
+            `Removing temp dir: ${path.join(getTempBasePackageDir(), dir)}`,
+          );
+          fs.rmSync(path.join(getTempBasePackageDir(), dir), {
+            force: true,
+            recursive: true,
+          });
+        }
+      }
+    }
+    runOnExit(() => {
+      logger.debug(`Removing temp dir: ${this.dir}`);
+      fs.rmSync(this.dir, {
+        force: true,
+        recursive: true,
+      });
+    });
+    logger.debug(`Created temp dir: ${this.dir}`);
+  }
+  createFilePath(fileName) {
+    return path.join(this.dir, fileName);
+  }
+  createFile({ name, content, mode }) {
+    this.initialize();
+    const filePath = this.createFilePath(name);
+    fs.writeFileSync(filePath, content, {
+      encoding: "utf8",
+      mode,
+    });
+    return {
+      filePath,
+      cleanup: () =>
+        fs.rmSync(filePath, {
+          force: true,
+        }),
+    };
+  }
+  cleanup() {
+    fs.rmSync(this.dir, {
+      force: true,
+      recursive: true,
+    });
+  }
+}
+let DEFAULT_TEMP_DIR;
+if (!validateCurrentBunVersion()) {
+  DEFAULT_TEMP_DIR = new TempDir();
+} else {
+  DEFAULT_TEMP_DIR = null;
+}
+
+export { DEFAULT_TEMP_DIR };

package/src/internal/core/runtime/terminal.d.ts

@@ -0,0 +1 @@
+export declare const IS_TTY: boolean;

package/src/internal/core/runtime/terminal.mjs

@@ -0,0 +1,4 @@
+// CONCATENATED MODULE: ./src/internal/core/runtime/terminal.ts
+const IS_TTY = !!process.stdout?.isTTY;
+
+export { IS_TTY };

package/src/internal/generated/ajv/validateRootConfig.mjs

@@ -0,0 +1 @@
+"use strict";module.exports = validate11;module.exports.default = validate11;const schema12 = {"type":"object","additionalProperties":false,"properties":{"defaults":{"type":"object","additionalProperties":false,"properties":{"parallelMax":{"type":["number","string"]},"shell":{"type":"string"},"includeRootWorkspace":{"type":"boolean"}}}}};function validate11(data, {instancePath="", parentData, parentDataProperty, rootData=data}={}){let vErrors = null;let errors = 0;if(errors === 0){if(data && typeof data == "object" && !Array.isArray(data)){const _errs1 = errors;for(const key0 in data){if(!(key0 === "defaults")){validate11.errors = [{instancePath,schemaPath:"#/additionalProperties",keyword:"additionalProperties",params:{additionalProperty: key0},message:"must NOT have additional properties"}];return false;break;}}if(_errs1 === errors){if(data.defaults !== undefined){let data0 = data.defaults;const _errs2 = errors;if(errors === _errs2){if(data0 && typeof data0 == "object" && !Array.isArray(data0)){const _errs4 = errors;for(const key1 in data0){if(!(((key1 === "parallelMax") || (key1 === "shell")) || (key1 === "includeRootWorkspace"))){validate11.errors = [{instancePath:instancePath+"/defaults",schemaPath:"#/properties/defaults/additionalProperties",keyword:"additionalProperties",params:{additionalProperty: key1},message:"must NOT have additional properties"}];return false;break;}}if(_errs4 === errors){if(data0.parallelMax !== undefined){let data1 = data0.parallelMax;const _errs5 = errors;if((!((typeof data1 == "number") && (isFinite(data1)))) && (typeof data1 !== "string")){validate11.errors = [{instancePath:instancePath+"/defaults/parallelMax",schemaPath:"#/properties/defaults/properties/parallelMax/type",keyword:"type",params:{type: schema12.properties.defaults.properties.parallelMax.type},message:"must be number,string"}];return false;}var valid1 = _errs5 === errors;}else {var valid1 = true;}if(valid1){if(data0.shell !== undefined){const _errs7 = errors;if(typeof data0.shell !== "string"){validate11.errors = [{instancePath:instancePath+"/defaults/shell",schemaPath:"#/properties/defaults/properties/shell/type",keyword:"type",params:{type: "string"},message:"must be string"}];return false;}var valid1 = _errs7 === errors;}else {var valid1 = true;}if(valid1){if(data0.includeRootWorkspace !== undefined){const _errs9 = errors;if(typeof data0.includeRootWorkspace !== "boolean"){validate11.errors = [{instancePath:instancePath+"/defaults/includeRootWorkspace",schemaPath:"#/properties/defaults/properties/includeRootWorkspace/type",keyword:"type",params:{type: "boolean"},message:"must be boolean"}];return false;}var valid1 = _errs9 === errors;}else {var valid1 = true;}}}}}else {validate11.errors = [{instancePath:instancePath+"/defaults",schemaPath:"#/properties/defaults/type",keyword:"type",params:{type: "object"},message:"must be object"}];return false;}}}}}else {validate11.errors = [{instancePath,schemaPath:"#/type",keyword:"type",params:{type: "object"},message:"must be object"}];return false;}}validate11.errors = vErrors;return errors === 0;}

package/src/internal/generated/ajv/validateWorkspaceConfig.mjs

@@ -0,0 +1 @@
+"use strict";module.exports = validate10;module.exports.default = validate10;const schema11 = {"type":"object","additionalProperties":false,"properties":{"alias":{"type":["string","array"],"items":{"type":"string"},"uniqueItems":true},"scripts":{"type":"object","additionalProperties":{"type":"object","properties":{"order":{"type":"number"}},"additionalProperties":false}}}};function validate10(data, {instancePath="", parentData, parentDataProperty, rootData=data}={}){let vErrors = null;let errors = 0;if(errors === 0){if(data && typeof data == "object" && !Array.isArray(data)){const _errs1 = errors;for(const key0 in data){if(!((key0 === "alias") || (key0 === "scripts"))){validate10.errors = [{instancePath,schemaPath:"#/additionalProperties",keyword:"additionalProperties",params:{additionalProperty: key0},message:"must NOT have additional properties"}];return false;break;}}if(_errs1 === errors){if(data.alias !== undefined){let data0 = data.alias;const _errs2 = errors;if((typeof data0 !== "string") && (!(Array.isArray(data0)))){validate10.errors = [{instancePath:instancePath+"/alias",schemaPath:"#/properties/alias/type",keyword:"type",params:{type: schema11.properties.alias.type},message:"must be string,array"}];return false;}if(errors === _errs2){if(Array.isArray(data0)){var valid1 = true;const len0 = data0.length;for(let i0=0; i0<len0; i0++){const _errs4 = errors;if(typeof data0[i0] !== "string"){validate10.errors = [{instancePath:instancePath+"/alias/" + i0,schemaPath:"#/properties/alias/items/type",keyword:"type",params:{type: "string"},message:"must be string"}];return false;}var valid1 = _errs4 === errors;if(!valid1){break;}}if(valid1){let i1 = data0.length;let j0;if(i1 > 1){const indices0 = {};for(;i1--;){let item0 = data0[i1];if(typeof item0 !== "string"){continue;}if(typeof indices0[item0] == "number"){j0 = indices0[item0];validate10.errors = [{instancePath:instancePath+"/alias",schemaPath:"#/properties/alias/uniqueItems",keyword:"uniqueItems",params:{i: i1, j: j0},message:"must NOT have duplicate items (items ## "+j0+" and "+i1+" are identical)"}];return false;break;}indices0[item0] = i1;}}}}}var valid0 = _errs2 === errors;}else {var valid0 = true;}if(valid0){if(data.scripts !== undefined){let data2 = data.scripts;const _errs6 = errors;if(errors === _errs6){if(data2 && typeof data2 == "object" && !Array.isArray(data2)){for(const key1 in data2){let data3 = data2[key1];const _errs9 = errors;if(errors === _errs9){if(data3 && typeof data3 == "object" && !Array.isArray(data3)){const _errs11 = errors;for(const key2 in data3){if(!(key2 === "order")){validate10.errors = [{instancePath:instancePath+"/scripts/" + key1.replace(/~/g, "~0").replace(/\//g, "~1"),schemaPath:"#/properties/scripts/additionalProperties/additionalProperties",keyword:"additionalProperties",params:{additionalProperty: key2},message:"must NOT have additional properties"}];return false;break;}}if(_errs11 === errors){if(data3.order !== undefined){let data4 = data3.order;if(!((typeof data4 == "number") && (isFinite(data4)))){validate10.errors = [{instancePath:instancePath+"/scripts/" + key1.replace(/~/g, "~0").replace(/\//g, "~1")+"/order",schemaPath:"#/properties/scripts/additionalProperties/properties/order/type",keyword:"type",params:{type: "number"},message:"must be number"}];return false;}}}}else {validate10.errors = [{instancePath:instancePath+"/scripts/" + key1.replace(/~/g, "~0").replace(/\//g, "~1"),schemaPath:"#/properties/scripts/additionalProperties/type",keyword:"type",params:{type: "object"},message:"must be object"}];return false;}}var valid3 = _errs9 === errors;if(!valid3){break;}}}else {validate10.errors = [{instancePath:instancePath+"/scripts",schemaPath:"#/properties/scripts/type",keyword:"type",params:{type: "object"},message:"must be object"}];return false;}}var valid0 = _errs6 === errors;}else {var valid0 = true;}}}}else {validate10.errors = [{instancePath,schemaPath:"#/type",keyword:"type",params:{type: "object"},message:"must be object"}];return false;}}validate10.errors = vErrors;return errors === 0;}

package/src/internal/logger/index.d.ts

@@ -0,0 +1 @@
+export * from "./logger";

package/src/internal/logger/index.mjs

@@ -0,0 +1 @@
+export * from "./logger.mjs"; // CONCATENATED MODULE: ./src/internal/logger/index.ts

package/src/internal/logger/logger.d.ts

@@ -0,0 +1,45 @@
+export declare const LOG_LEVELS: readonly ["debug", "info", "warn", "error"];
+export type LogLevel = (typeof LOG_LEVELS)[number];
+export type LogLevelSetting = LogLevel | "silent";
+export declare const LOGGER_ERRORS: import("../core").DefinedErrors<"InvalidLogLevel">;
+export declare const validateLogLevel: (level: LogLevelSetting) => void;
+export type LogMetadata = Record<string, unknown>;
+export interface Log<
+  Message extends string | Error = string,
+  Metadata extends LogMetadata = LogMetadata,
+> {
+  message: Message;
+  level: LogLevel;
+  metadata: Metadata;
+  time: Date;
+}
+export type Logger = {
+  name: string;
+  log<
+    Message extends string | Error = string,
+    Metadata extends LogMetadata = LogMetadata,
+  >(
+    message: Message,
+    level: LogLevel,
+    metadata?: Metadata,
+  ): Log<Message, Metadata>;
+  printLevel: LogLevelSetting;
+  setPrintStdout: (
+    stdout: (...args: Parameters<typeof process.stdout.write>) => void,
+  ) => void;
+  setPrintStderr: (
+    stderr: (...args: Parameters<typeof process.stderr.write>) => void,
+  ) => void;
+} & {
+  [Level in LogLevel]: <
+    Message extends string | Error = string,
+    Metadata extends LogMetadata = LogMetadata,
+  >(
+    message: Message,
+    metadata?: Metadata,
+  ) => Log<Message, Metadata>;
+};
+export declare const createLogger: (name: string) => Logger;
+export declare const logger: Logger;
+/** Set the global logging level. Defaults to "info" or "error" when `NODE_ENV` is "test" */
+export declare const setLogLevel: (level: LogLevelSetting) => void;

package/src/internal/logger/logger.mjs

@@ -0,0 +1,133 @@
+import { defineErrors } from "../core/error/index.mjs";
+import { IS_TEST } from "../core/runtime/env.mjs"; // CONCATENATED MODULE: external "../core/error/index.mjs"
+// CONCATENATED MODULE: external "../core/runtime/env.mjs"
+// CONCATENATED MODULE: ./src/internal/logger/logger.ts
+
+const LOG_LEVELS = ["debug", "info", "warn", "error"];
+const getLevelNumber = (level) => LOG_LEVELS.indexOf(level);
+const LOGGER_ERRORS = defineErrors("InvalidLogLevel");
+const validateLogLevel = (level) => {
+  if (level === "silent") return;
+  if (!LOG_LEVELS.includes(level)) {
+    throw new LOGGER_ERRORS.InvalidLogLevel(
+      `Invalid log level: ${JSON.stringify(level)}. Accepted values: ${LOG_LEVELS.join(", ") + ", silent"}`,
+    );
+  }
+};
+const createLogger = (name) => new _Logger(name);
+const YELLOW = "\x1b[0;33m";
+const NC = "\x1b[0m";
+const RED = "\x1b[0;31m";
+const LEVEL_OUTPUT_TARGETS = {
+  debug: "stderr",
+  info: "stdout",
+  warn: "stderr",
+  error: "stderr",
+};
+class _Logger {
+  name;
+  constructor(name) {
+    this.name = name;
+  }
+  log(message, level, metadata) {
+    const log = {
+      message,
+      level,
+      metadata: metadata ?? {},
+      time: new Date(),
+    };
+    if (this.shouldPrint(level)) {
+      const formattedMessage = this.formatLogMessage(message, level);
+      if (message instanceof Error) {
+        message.message = formattedMessage;
+      }
+      const mainMessage = message instanceof Error ? message : formattedMessage;
+      const metadataMessages = metadata
+        ? [
+            {
+              metadata,
+            },
+          ]
+        : [];
+      this[
+        LEVEL_OUTPUT_TARGETS[level] === "stderr"
+          ? "_printStderr"
+          : "_printStdout"
+      ](
+        (typeof mainMessage === "string"
+          ? mainMessage
+          : Bun.inspect(mainMessage, {
+              colors: true,
+            })) +
+          metadataMessages
+            .map((m) =>
+              Bun.inspect(m, {
+                colors: true,
+              }),
+            )
+            .join("\n") +
+          "\n",
+      );
+    }
+    return log;
+  }
+  debug(message, metadata) {
+    return this.log(message, "debug", metadata);
+  }
+  info(message, metadata) {
+    return this.log(message, "info", metadata);
+  }
+  warn(message, metadata) {
+    return this.log(message, "warn", metadata);
+  }
+  error(message, metadata) {
+    return this.log(message, "error", metadata);
+  }
+  get printLevel() {
+    return this._printLevel;
+  }
+  set printLevel(level) {
+    validateLogLevel(level);
+    this._printLevel = level;
+  }
+  // Info prints normally for standard user-facing logs. Debug and Warn are highlighted with a prefix. Errors print as Error instances
+  formatLogMessage(message, level) {
+    const content = message instanceof Error ? message.message : message;
+    const prefixed =
+      level === "debug" || level === "warn"
+        ? `[${this.name} ${level.toUpperCase()}]: ${content}`
+        : content;
+    return level === "warn"
+      ? `${YELLOW}${prefixed}${NC}`
+      : level === "error"
+        ? `${RED}${prefixed}${NC}`
+        : prefixed;
+  }
+  _printLevel = IS_TEST ? "error" : "info";
+  shouldPrint(level) {
+    if (this.printLevel === "silent") return false;
+    return getLevelNumber(level) >= getLevelNumber(this.printLevel);
+  }
+  _printStdout = (...args) => process.stdout.write(...args);
+  _printStderr = (...args) => process.stderr.write(...args);
+  setPrintStdout(stdout) {
+    this._printStdout = stdout;
+  }
+  setPrintStderr(stderr) {
+    this._printStderr = stderr;
+  }
+}
+const logger = createLogger("bun-workspaces");
+/** Set the global logging level. Defaults to "info" or "error" when `NODE_ENV` is "test" */ const setLogLevel =
+  (level) => {
+    logger.printLevel = level;
+  };
+
+export {
+  LOGGER_ERRORS,
+  LOG_LEVELS,
+  createLogger,
+  logger,
+  setLogLevel,
+  validateLogLevel,
+};

package/src/internal/version.d.ts

@@ -0,0 +1 @@
+export declare const BUN_WORKSPACES_VERSION: string;

package/src/internal/version.mjs

@@ -0,0 +1,6 @@
+import package_0 from "../../package.json"; // CONCATENATED MODULE: external "../../package.json"
+// CONCATENATED MODULE: ./src/internal/version.ts
+
+const BUN_WORKSPACES_VERSION = package_0.version;
+
+export { BUN_WORKSPACES_VERSION };

package/src/project/errors.d.ts

@@ -0,0 +1,5 @@
+export declare const PROJECT_ERRORS: import("../internal/core").DefinedErrors<
+  | "ProjectWorkspaceNotFound"
+  | "WorkspaceScriptDoesNotExist"
+  | "RecursiveWorkspaceScript"
+>;

package/src/project/errors.mjs

@@ -0,0 +1,10 @@
+import { defineErrors } from "../internal/core/index.mjs"; // CONCATENATED MODULE: external "../internal/core/index.mjs"
+// CONCATENATED MODULE: ./src/project/errors.ts
+
+const PROJECT_ERRORS = defineErrors(
+  "ProjectWorkspaceNotFound",
+  "WorkspaceScriptDoesNotExist",
+  "RecursiveWorkspaceScript",
+);
+
+export { PROJECT_ERRORS };

package/src/project/implementations/fileSystemProject.d.ts

@@ -0,0 +1,148 @@
+import type { Simplify } from "../../internal/core";
+import {
+  type RunScriptsParallelOptions,
+  type RunScriptsSummary,
+  type RunScriptExit,
+  type OutputStreamName,
+  type ScriptEventName,
+} from "../../runScript";
+import type { MultiProcessOutput } from "../../runScript/output/multiProcessOutput";
+import { type ScriptShellOption } from "../../runScript/scriptShellOption";
+import { type Workspace } from "../../workspaces";
+import type { Project, ProjectConfig } from "../project";
+import { ProjectBase } from "./projectBase";
+/** Arguments for {@link createFileSystemProject} */
+export type CreateFileSystemProjectOptions = {
+  /** The directory containing the root package.json. Often the same root as a git repository. Relative to process.cwd(). The default is process.cwd(). */
+  rootDirectory?: string;
+  /**
+   * The name of the project.
+   *
+   * By default will use the root package.json name
+   */
+  name?: string;
+  /** Whether to include the root workspace as a normal workspace. This overrides any config or env var settings. */
+  includeRootWorkspace?: boolean;
+};
+export type ShellOption = ScriptShellOption | "default";
+export type InlineScriptOptions = {
+  /** A name to act as a label for the inline script */
+  scriptName?: string;
+  /** Whether to run the script as an inline command */
+  shell?: ShellOption;
+};
+/** Arguments for `FileSystemProject.runWorkspaceScript` */
+export type RunWorkspaceScriptOptions = {
+  /** The name of the workspace to run the script in */
+  workspaceNameOrAlias: string;
+  /** The name of the script to run, or an inline command when `inline` is true */
+  script: string;
+  /** Whether to run the script as an inline command */
+  inline?: boolean | InlineScriptOptions;
+  /** The arguments to append to the script command */
+  args?: string;
+  /** Set to `true` to ignore all output from the script. This saves memory when you don't need script output. */
+  ignoreOutput?: boolean;
+};
+/** Metadata associated with a workspace script */
+export type RunWorkspaceScriptMetadata = {
+  /** The workspace that the script was run in */
+  workspace: Workspace;
+};
+export type RunWorkspaceScriptExit = Simplify<
+  RunScriptExit<RunWorkspaceScriptMetadata>
+>;
+export type RunWorkspaceScriptProcessOutput = MultiProcessOutput<
+  RunWorkspaceScriptMetadata & {
+    streamName: OutputStreamName;
+  }
+>;
+/** Result of `FileSystemProject.runWorkspaceScript` */
+export type RunWorkspaceScriptResult = {
+  /** Use to get the output of the script */
+  output: RunWorkspaceScriptProcessOutput;
+  /** The exit result of the script */
+  exit: Promise<RunWorkspaceScriptExit>;
+};
+export type ParallelOption = boolean | RunScriptsParallelOptions;
+export type ScriptEventMetadata = {
+  /** The workspace that the script event occurred in */
+  workspace: Workspace;
+  /** The exit result of the script */
+  exitResult: RunScriptExit<RunWorkspaceScriptMetadata> | null;
+};
+export type OnScriptEventCallback = (
+  /** The event that occurred */
+  event: ScriptEventName,
+  /** The metadata for the script event */
+  metadata: ScriptEventMetadata,
+) => unknown;
+/** Arguments for `FileSystemProject.runScriptAcrossWorkspaces` */
+export type RunScriptAcrossWorkspacesOptions = {
+  /**
+   * Workspace names, aliases, or patterns including a wildcard.
+   *
+   * When not provided, all workspaces that the script can be ran in will be used.
+   */
+  workspacePatterns?: string[];
+  /** The name of the script to run, or an inline command when `inline` is true */
+  script: string;
+  /** Whether to run the script as an inline command */
+  inline?: boolean | InlineScriptOptions;
+  /** The arguments to append to the script command. `<workspaceName>` will be replaced with the workspace name */
+  args?: string;
+  /** Whether to run the scripts in parallel (default: `true`). Pass `false` to run in series. */
+  parallel?: ParallelOption;
+  /** When `true`, run scripts so that dependent workspaces run only after their dependencies */
+  dependencyOrder?: boolean;
+  /** When `true`, continue running scripts even if a dependency fails (Only relevant when `dependencyOrder` is `true`) */
+  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 (start, skip, exit) */
+  onScriptEvent?: OnScriptEventCallback;
+};
+export type RunScriptAcrossWorkspacesSummary = Simplify<
+  RunScriptsSummary<RunWorkspaceScriptMetadata>
+>;
+export type RunScriptAcrossWorkspacesOutput = MultiProcessOutput<
+  RunWorkspaceScriptMetadata & {
+    streamName: OutputStreamName;
+  }
+>;
+/** Result of `FileSystemProject.runScriptAcrossWorkspaces` */
+export type RunScriptAcrossWorkspacesResult = {
+  /** Use to get the output of the scripts */
+  output: RunScriptAcrossWorkspacesOutput;
+  /** The summary of the script run with exit details for each workspace */
+  summary: Promise<RunScriptAcrossWorkspacesSummary>;
+  /** The workspaces targeted */
+  workspaces: Workspace[];
+};
+declare class _FileSystemProject extends ProjectBase implements Project {
+  #private;
+  readonly rootDirectory: string;
+  readonly workspaces: Workspace[];
+  readonly name: string;
+  readonly sourceType = "fileSystem";
+  readonly config: ProjectConfig;
+  readonly rootWorkspace: Workspace;
+  constructor(options: CreateFileSystemProjectOptions);
+  runWorkspaceScript(
+    options: RunWorkspaceScriptOptions,
+  ): RunWorkspaceScriptResult;
+  runScriptAcrossWorkspaces(
+    options: RunScriptAcrossWorkspacesOptions,
+  ): RunScriptAcrossWorkspacesResult;
+}
+/** An implementation of {@link Project} that is created from a root directory in the file system. */
+export type FileSystemProject = Simplify<_FileSystemProject>;
+/**
+ * Create a {@link Project} based on a given root directory.
+ * Automatically finds workspaces based on the root package.json "workspaces" field
+ * and detects and utilizes any provided configuration.
+ */
+export declare const createFileSystemProject: (
+  options?: CreateFileSystemProjectOptions,
+) => FileSystemProject;
+export {};