bun-workspaces 1.0.0-alpha.36 → 1.0.0-alpha.38

package/README.md

@@ -67,6 +67,13 @@ bw run lint my-alias-a my-alias-b # Run by alias (set by optional config)
 bw run lint "my-workspace-*" # Run for matching workspace names
 bw run lint "alias:my-alias-pattern-*" "path:my-glob/**/*" # Use matching specifiers
 
+# A workspace's script will wait until any workspaces it depends on have completed
+# Similar to Bun's --filter behavior
+bw run lint --dep-order
+
+# Continue running scripts even if a dependency fails
+bw run lint --dep-order --ignore-dep-failure
+
 bw run lint --args="--my-appended-args" # Add args to each script call
 bw run lint --args="--my-arg=<workspaceName>" # Use the workspace name in args
 
@@ -120,11 +127,10 @@ const runSingleScript = async () => {
   });
 
   // Get a stream of the script subprocess's output
-  for await (const { outputChunk } of output) {
-    // outputChunk.raw // The raw output content (Uint8Array)
-    // outputChunk.decode() // The output chunk's content (string)
-    // outputChunk.decode({ stripAnsi: true }) // Text with ANSI codes sanitized (string)
-    // outputChunk.streamName // The output stream, "stdout" or "stderr"
+  for await (const { chunk, metadata } of output.text()) {
+    // console.log(chunk); // the content (string)
+    // console.log(metadata.streamName); // "stdout" or "stderr"
+    // console.log(metadata.workspace); // the workspace that the output came from
   }
 
   // Get data about the script execution after it exits
@@ -155,16 +161,21 @@ const runManyScripts = async () => {
 
     // Optional. Whether to run the scripts in parallel
     parallel: true,
+
+    // Optional. When true, a workspace's script will wait
+    // until any workspaces it depends on have completed
+    dependencyOrder: true,
+
+    // Optional. When true and dependencyOrder is true,
+    // continue running scripts even if a dependency fails
+    ignoreDependencyFailure: true,
   });
 
   // Get a stream of script output
-  for await (const { outputChunk, scriptMetadata } of output) {
-    // outputChunk.decode() // the output chunk's content (string)
-    // outputChunk.decode({ stripAnsi: true }) // text with ANSI codes sanitized (string)
-    // outputChunk.streamName // "stdout" or "stderr"
-    // The metadata can distinguish which workspace script
-    // the current output chunk came from
-    // scriptMetadata.workspace // Workspace object
+  for await (const { chunk, metadata } of output.text()) {
+    // console.log(chunk); // the content (string)
+    // console.log(metadata.streamName); // "stdout" or "stderr"
+    // console.log(metadata.workspace); // the workspace that the output came from
   }
 
   // Get final summary data and script exit details after all scripts have completed
@@ -191,7 +202,7 @@ const runManyScripts = async () => {
 };
 ```
 
-_`bun-workspaces` is independent from the [Bun](https://bun.sh) project and is not affiliated with or endorsed by Anthropic. This project aims to enhance enhance the experience of Bun for its users._
+_`bun-workspaces` is independent from the [Bun](https://bun.sh) project and is not affiliated with or endorsed by Anthropic. This project aims to enhance the experience of Bun for its users._
 
 Developed By:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bun-workspaces",
-  "version": "1.0.0-alpha.36",
+  "version": "1.0.0-alpha.38",
   "description": "A monorepo management tool for Bun, with a CLI and API to enhance Bun's native workspaces.",
   "license": "MIT",
   "main": "src/index.mjs",

package/src/cli/commands/commandHandlerUtils.mjs

@@ -19,6 +19,8 @@ const createWorkspaceInfoLines = (workspace) => [
   ` - Path: ${workspace.path}`,
   ` - Glob Match: ${workspace.matchPattern}`,
   ` - Scripts: ${workspace.scripts.join(", ")}`,
+  ` - Dependencies: ${workspace.dependencies.join(", ")}`,
+  ` - Dependents: ${workspace.dependents.join(", ")}`,
 ];
 const createScriptInfoLines = (script, workspaces) => [
   `Script: ${script}`,

package/src/cli/commands/commands.mjs

@@ -1,12 +1,12 @@
-import { runScript } from "./handleRunScript.mjs";
 import {
   doctor,
   listScripts,
   listWorkspaces,
   scriptInfo,
   workspaceInfo,
-} from "./handleSimpleCommands.mjs"; // CONCATENATED MODULE: external "./handleRunScript.mjs"
-// CONCATENATED MODULE: external "./handleSimpleCommands.mjs"
+} from "./handleSimpleCommands.mjs";
+import { runScript } from "./runScript/index.mjs"; // CONCATENATED MODULE: external "./handleSimpleCommands.mjs"
+// CONCATENATED MODULE: external "./runScript/index.mjs"
 // CONCATENATED MODULE: ./src/cli/commands/commands.ts
 
 const defineGlobalCommands = (context) => {

package/src/cli/commands/commandsConfig.d.ts

@@ -161,6 +161,14 @@ export declare const CLI_COMMANDS_CONFIG: {
         readonly values: ["bun", "system", "default"];
         readonly description: "When using --inline, the shell to use to run the script";
       };
+      readonly depOrder: {
+        readonly flags: ["-d", "--dep-order"];
+        readonly description: "Scripts for dependent workspaces run only after their dependencies";
+      };
+      readonly ignoreDepFailure: {
+        readonly flags: ["-f", "--ignore-dep-failure"];
+        readonly description: "In dependency order, continue running scripts even if a dependency fails";
+      };
       readonly jsonOutfile: {
         readonly flags: ["-j", "--json-outfile <file>"];
         readonly description: "Output results in a JSON file";
@@ -304,6 +312,14 @@ export declare const getCliCommandConfig: (commandName: CliCommandName) =>
           readonly values: ["bun", "system", "default"];
           readonly description: "When using --inline, the shell to use to run the script";
         };
+        readonly depOrder: {
+          readonly flags: ["-d", "--dep-order"];
+          readonly description: "Scripts for dependent workspaces run only after their dependencies";
+        };
+        readonly ignoreDepFailure: {
+          readonly flags: ["-f", "--ignore-dep-failure"];
+          readonly description: "In dependency order, continue running scripts even if a dependency fails";
+        };
         readonly jsonOutfile: {
           readonly flags: ["-j", "--json-outfile <file>"];
           readonly description: "Output results in a JSON file";

package/src/cli/commands/commandsConfig.mjs

@@ -141,6 +141,16 @@ const CLI_COMMANDS_CONFIG = {
         values: [...SCRIPT_SHELL_OPTIONS, "default"],
         description: `When using --inline, the shell to use to run the script`,
       },
+      depOrder: {
+        flags: ["-d", "--dep-order"],
+        description:
+          "Scripts for dependent workspaces run only after their dependencies",
+      },
+      ignoreDepFailure: {
+        flags: ["-f", "--ignore-dep-failure"],
+        description:
+          "In dependency order, continue running scripts even if a dependency fails",
+      },
       jsonOutfile: {
         flags: ["-j", "--json-outfile <file>"],
         description: "Output results in a JSON file",

package/src/cli/commands/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./commands";
 export * from "./commandsConfig";
+export * from "./runScript";

package/src/cli/commands/index.mjs

@@ -1,2 +1,3 @@
 export * from "./commands.mjs";
-export * from "./commandsConfig.mjs"; // CONCATENATED MODULE: ./src/cli/commands/index.ts
+export * from "./commandsConfig.mjs";
+export * from "./runScript/index.mjs"; // CONCATENATED MODULE: ./src/cli/commands/index.ts

package/src/cli/commands/runScript/formatRunScriptOutput.d.ts

@@ -0,0 +1,19 @@
+import type {
+  RunScriptAcrossWorkspacesProcessOutput,
+  RunWorkspaceScriptMetadata,
+} from "../../../project";
+import type { OutputStreamName } from "../../../runScript";
+export type FormatRunScriptOutputOptions = {
+  stripDisruptiveControls?: boolean;
+  prefix?: boolean;
+  scriptName: string;
+};
+export declare function formatRunScriptOutput(
+  output: RunScriptAcrossWorkspacesProcessOutput,
+  { scriptName, stripDisruptiveControls, prefix }: FormatRunScriptOutputOptions,
+): AsyncGenerator<{
+  line: string;
+  metadata: RunWorkspaceScriptMetadata & {
+    streamName: OutputStreamName;
+  };
+}>;

package/src/cli/commands/runScript/formatRunScriptOutput.mjs

@@ -0,0 +1,126 @@
+// CONCATENATED MODULE: ./src/cli/commands/runScript/formatRunScriptOutput.ts
+const sanitizeChunk = (input, stripDisruptiveControls = false) => {
+  if (!stripDisruptiveControls) {
+    return input.replace(/\r\n/g, "\n");
+  }
+  // 1) Normalize newline-ish controls
+  let s = input
+    .replace(/\r\n/g, "\n")
+    .replace(/\r/g, "\n")
+    .replace(/\f/g, "\n")
+    .replace(/\v/g, "\n");
+  // 2) Remove disruptive single-byte controls (except \n, \t)
+  //    - backspace, bell, and C1 controls
+  // eslint-disable-next-line no-control-regex
+  s = s.replace(/[\b\x07\x80-\x9F]/g, "");
+  // 3) Strip ANSI sequences, keeping only SGR (CSI ... m)
+  //
+  // We'll scan rather than rely on one giant regex so we can:
+  // - keep SGR exactly
+  // - drop any other ESC sequence
+  // - handle incomplete ESC sequences conservatively (drop the ESC byte itself)
+  //
+  // ESC = \x1B
+  const ESC = "\x1B";
+  let out = "";
+  for (let i = 0; i < s.length; i++) {
+    const ch = s[i];
+    if (ch !== ESC) {
+      out += ch;
+      continue;
+    }
+    // If ESC is last char, drop it
+    if (i + 1 >= s.length) break;
+    const next = s[i + 1];
+    // Keep only CSI ... m  (ESC [ ... m)
+    if (next === "[") {
+      // Find final byte of CSI sequence (per spec: 0x40-0x7E).
+      // We only keep it if the final byte is 'm'.
+      let j = i + 2;
+      while (j < s.length) {
+        const code = s.charCodeAt(j);
+        if (code >= 0x40 && code <= 0x7e) break; // final byte
+        j++;
+      }
+      // If we didn't find a final byte, drop the ESC and stop (incomplete)
+      if (j >= s.length) break;
+      const finalByte = s[j];
+      if (finalByte === "m") {
+        // Keep full SGR sequence
+        out += s.slice(i, j + 1);
+      }
+      // else: drop the entire CSI sequence
+      i = j; // advance past sequence
+      continue;
+    }
+    // All other ESC sequences: drop them.
+    //
+    // For 2-byte sequences (like ESC c), we can just drop ESC+next.
+    // For string-terminated families (OSC/DCS/APC/PM/SOS), we should skip until terminator.
+    //
+    // OSC: ESC ] ... (BEL or ESC \)
+    // DCS: ESC P ... (ST = ESC \)
+    // APC: ESC _ ... (ST)
+    // PM : ESC ^ ... (ST)
+    // SOS: ESC X ... (ST)
+    if (
+      next === "]" ||
+      next === "P" ||
+      next === "_" ||
+      next === "^" ||
+      next === "X"
+    ) {
+      let j = i + 2;
+      while (j < s.length) {
+        const c = s[j];
+        // BEL terminator (OSC can end with BEL)
+        if (c === "\x07") {
+          j++;
+          break;
+        }
+        // ST terminator: ESC \
+        if (c === ESC && j + 1 < s.length && s[j + 1] === "\\") {
+          j += 2;
+          break;
+        }
+        j++;
+      }
+      i = j - 1; // -1 because loop will i++
+      continue;
+    }
+    // Fallback: treat as a 2-byte escape and drop ESC + next.
+    i += 1;
+  }
+  return out;
+};
+async function* formatRunScriptOutput(
+  output,
+  { scriptName, stripDisruptiveControls = true, prefix = false },
+) {
+  const workspaceLineBuffers = {};
+  const formatLine = (line, workspaceName, scriptName) => {
+    const prefixedLine = prefix
+      ? `[${workspaceName}:${scriptName}] ${line}`
+      : line;
+    return `\x1b[0m${prefixedLine}\n`;
+  };
+  for await (const { metadata, chunk } of output.text()) {
+    const workspaceName = metadata.workspace.name;
+    const sanitizedChunk = sanitizeChunk(chunk, stripDisruptiveControls);
+    const prior = workspaceLineBuffers[workspaceName] ?? "";
+    const content = prior + sanitizedChunk;
+    const lines = content.split("\n");
+    for (const line of lines) {
+      if (line)
+        yield {
+          line: formatLine(line, workspaceName, scriptName),
+          metadata,
+        };
+    }
+    workspaceLineBuffers[workspaceName] = content.endsWith("\n")
+      ? ""
+      : (lines[lines.length - 1] ?? "");
+  }
+}
+
+export { formatRunScriptOutput };

package/src/cli/commands/{handleRunScript.d.ts → runScript/handleRunScript.d.ts}

@@ -1,3 +1,3 @@
 export declare const runScript: (
-  context: import("./commandHandlerUtils").ProjectCommandContext,
+  context: import("../commandHandlerUtils").ProjectCommandContext,
 ) => import("commander").Command;

package/src/cli/commands/{handleRunScript.mjs → runScript/handleRunScript.mjs}

@@ -1,15 +1,16 @@
 import fs from "fs";
 import path from "path";
-import { logger } from "../../internal/logger/index.mjs";
+import { logger } from "../../../internal/logger/index.mjs";
 import {
-  commandOutputLogger,
   handleProjectCommand,
   splitWorkspacePatterns,
-} from "./commandHandlerUtils.mjs"; // CONCATENATED MODULE: external "fs"
+} from "../commandHandlerUtils.mjs";
+import { formatRunScriptOutput } from "./formatRunScriptOutput.mjs"; // CONCATENATED MODULE: external "fs"
 // CONCATENATED MODULE: external "path"
-// CONCATENATED MODULE: external "../../internal/logger/index.mjs"
-// CONCATENATED MODULE: external "./commandHandlerUtils.mjs"
-// CONCATENATED MODULE: ./src/cli/commands/handleRunScript.ts
+// CONCATENATED MODULE: external "../../../internal/logger/index.mjs"
+// CONCATENATED MODULE: external "../commandHandlerUtils.mjs"
+// CONCATENATED MODULE: external "./formatRunScriptOutput.mjs"
+// CONCATENATED MODULE: ./src/cli/commands/runScript/handleRunScript.ts
 
 const runScript = handleProjectCommand(
   "runScript",
@@ -52,6 +53,9 @@ const runScript = handleProjectCommand(
     logger.debug(
       `Command: Run script ${JSON.stringify(script)} for ${workspacePatterns.length ? "workspaces " + workspacePatterns.join(", ") : "all workspaces"} (parallel: ${!!options.parallel}, args: ${JSON.stringify(scriptArgs)})`,
     );
+    const workspaceCount = project.findWorkspacesByPattern(
+      ...workspacePatterns,
+    ).length;
     const { output, summary } = project.runScriptAcrossWorkspaces({
       workspacePatterns: workspacePatterns.length
         ? workspacePatterns
@@ -66,6 +70,8 @@ const runScript = handleProjectCommand(
           : true
         : undefined,
       args: scriptArgs,
+      dependencyOrder: options.depOrder,
+      ignoreDependencyFailure: options.ignoreDepFailure,
       parallel:
         typeof options.parallel === "boolean" ||
         typeof options.parallel === "undefined"
@@ -83,33 +89,41 @@ const runScript = handleProjectCommand(
       : script;
     const handleOutput = async () => {
       if (logger.printLevel === "silent") return;
-      for await (const { outputChunk, scriptMetadata } of output) {
-        commandOutputLogger.logOutput(
-          outputChunk.decode(),
-          "info",
-          process[outputChunk.streamName],
-          options.prefix
-            ? `[${scriptMetadata.workspace.name}:${scriptName}] `
-            : "",
-        );
+      for await (const { line, metadata } of formatRunScriptOutput(output, {
+        prefix: options.prefix,
+        scriptName,
+        stripDisruptiveControls: workspaceCount > 1 || !!options.parallel,
+      })) {
+        process[metadata.streamName].write(line);
       }
     };
     handleOutput();
     const exitResults = await summary;
     exitResults.scriptResults.forEach(
       ({ success, metadata: { workspace }, exitCode }) => {
-        logger.info(
-          `${success ? "✅" : "❌"} ${workspace.name}: ${scriptName}${exitCode ? ` (exited with code ${exitCode})` : ""}`,
-        );
+        const isSkipped = exitCode === -1;
+        if (isSkipped) {
+          logger.info(
+            `➖ ${workspace.name}: ${scriptName} (skipped due to dependency failure)`,
+          );
+        } else {
+          logger.info(
+            `${success ? "✅" : "❌"} ${workspace.name}: ${scriptName}${exitCode ? ` (exited with code ${exitCode})` : ""}`,
+          );
+        }
       },
     );
     const s = exitResults.scriptResults.length === 1 ? "" : "s";
+    const skippedCount = exitResults.scriptResults.filter(
+      ({ exitCode }) => exitCode === -1,
+    ).length;
+    const skippedMessage = skippedCount ? ` (${skippedCount} skipped)` : "";
     if (exitResults.failureCount) {
-      const message = `${exitResults.failureCount} of ${exitResults.scriptResults.length} script${s} failed`;
+      const message = `${exitResults.failureCount} of ${exitResults.scriptResults.length} script${s} failed${skippedMessage}`;
       logger.info(message);
     } else {
       logger.info(
-        `${exitResults.scriptResults.length} script${s} ran successfully`,
+        `${exitResults.scriptResults.length} script${s} ran successfully${skippedMessage}`,
       );
     }
     if (options.jsonOutfile) {

package/src/cli/commands/runScript/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./handleRunScript";
+export * from "./formatRunScriptOutput";

package/src/cli/commands/runScript/index.mjs

@@ -0,0 +1,2 @@
+export * from "./handleRunScript.mjs";
+export * from "./formatRunScriptOutput.mjs"; // CONCATENATED MODULE: ./src/cli/commands/runScript/index.ts

package/src/config/util/loadConfig.d.ts

@@ -1,6 +1,6 @@
 import { type AnyFunction } from "../../internal/core";
 import { type ConfigLocation } from "./configLocation";
-export declare const InvalidJSONError: typeof import("../../internal/core").BunWorkspacesError;
+export declare const InvalidJSONError: typeof import("../..").BunWorkspacesError;
 export declare const getConfigLocation: (
   name: string,
   directory: string,

package/src/index.d.ts

@@ -11,9 +11,13 @@ export {
   type WorkspaceScriptMetadata,
   type RunWorkspaceScriptMetadata,
   type RunWorkspaceScriptOptions,
+  type RunWorkspaceScriptExit,
   type RunWorkspaceScriptResult,
   type InlineScriptOptions,
   type RunScriptAcrossWorkspacesOptions,
+  type RunScriptAcrossWorkspacesOutput,
+  type RunScriptAcrossWorkspacesSummary,
+  type RunScriptAcrossWorkspacesProcessOutput,
   type RunScriptAcrossWorkspacesResult,
   type ParallelOption,
   type ShellOption,
@@ -28,5 +32,5 @@ export {
   type RunScriptsParallelOptions,
 } from "./runScript";
 export { type Workspace } from "./workspaces";
-export { type SimpleAsyncIterable } from "./internal/core";
+export { type SimpleAsyncIterable, BunWorkspacesError } from "./internal/core";
 export { setLogLevel, type LogLevelSetting } from "./internal/logger";

package/src/index.mjs

@@ -2,8 +2,15 @@ import {
   createFileSystemProject,
   createMemoryProject,
 } from "./project/index.mjs";
+import { BunWorkspacesError } from "./internal/core/index.mjs";
 import { setLogLevel } from "./internal/logger/index.mjs"; // CONCATENATED MODULE: external "./project/index.mjs"
+// CONCATENATED MODULE: external "./internal/core/index.mjs"
 // CONCATENATED MODULE: external "./internal/logger/index.mjs"
 // CONCATENATED MODULE: ./src/index.ts
 
-export { createFileSystemProject, createMemoryProject, setLogLevel };
+export {
+  BunWorkspacesError,
+  createFileSystemProject,
+  createMemoryProject,
+  setLogLevel,
+};

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

@@ -22,12 +22,6 @@ export type Logger = {
     level: LogLevel,
     metadata?: Metadata,
   ): Log<Message, Metadata>;
-  logOutput(
-    chunk: Uint8Array | string,
-    level: LogLevel,
-    stream: NodeJS.WriteStream,
-    prefix: string,
-  ): Log<string, Record<string, unknown>>;
   printLevel: LogLevelSetting;
 } & {
   [Level in LogLevel]: <

package/src/internal/logger/logger.mjs

@@ -48,30 +48,6 @@ class _Logger {
     }
     return log;
   }
-  logOutput(chunk, level, stream, prefix) {
-    const message =
-      typeof chunk === "string"
-        ? chunk.trim()
-        : new TextDecoder().decode(chunk).trim();
-    const log = {
-      message,
-      level,
-      metadata: {
-        stream,
-        isLogOutput: true,
-      },
-      time: new Date(),
-    };
-    if (!this.shouldPrint(level)) {
-      return log;
-    }
-    const linePrefix = `${prefix}\x1b[0m`;
-    const lines = message.split(/\r?\n/);
-    lines.forEach((line) => {
-      if (line) stream.write(linePrefix + line + "\n");
-    });
-    return log;
-  }
   debug(message, metadata) {
     return this.log(message, "debug", metadata);
   }

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

@@ -1,9 +1,13 @@
-import type { Simplify } from "../../internal/core";
+import type { SimpleAsyncIterable, Simplify } from "../../internal/core";
 import {
-  type RunScriptResult,
-  type RunScriptsResult,
   type RunScriptsParallelOptions,
+  type RunScriptsSummary,
+  type RunScriptsOutput,
+  type RunScriptExit,
+  type OutputChunk,
+  type OutputStreamName,
 } 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";
@@ -43,10 +47,21 @@ export type RunWorkspaceScriptOptions = {
 export type RunWorkspaceScriptMetadata = {
   workspace: Workspace;
 };
-/** Result of `FileSystemProject.runWorkspaceScript` */
-export type RunWorkspaceScriptResult = Simplify<
-  RunScriptResult<RunWorkspaceScriptMetadata>
+export type RunWorkspaceScriptExit = Simplify<
+  RunScriptExit<RunWorkspaceScriptMetadata>
 >;
+export type RunWorkspaceScriptProcessOutput = MultiProcessOutput<
+  RunWorkspaceScriptMetadata & {
+    streamName: OutputStreamName;
+  }
+> &
+  /** @deprecated */
+  SimpleAsyncIterable<OutputChunk>;
+/** Result of `FileSystemProject.runWorkspaceScript` */
+export type RunWorkspaceScriptResult = {
+  output: RunWorkspaceScriptProcessOutput;
+  exit: Promise<RunWorkspaceScriptExit>;
+};
 export type ParallelOption = boolean | RunScriptsParallelOptions;
 /** Arguments for `FileSystemProject.runScriptAcrossWorkspaces` */
 export type RunScriptAcrossWorkspacesOptions = {
@@ -64,11 +79,29 @@ export type RunScriptAcrossWorkspacesOptions = {
   args?: string;
   /** Whether to run the scripts in parallel (series by default) */
   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;
 };
-/** Result of `FileSystemProject.runScriptAcrossWorkspaces` */
-export type RunScriptAcrossWorkspacesResult = Simplify<
-  RunScriptsResult<RunWorkspaceScriptMetadata>
+export type RunScriptAcrossWorkspacesOutput = Simplify<
+  RunScriptsOutput<RunWorkspaceScriptMetadata>
 >;
+export type RunScriptAcrossWorkspacesSummary = Simplify<
+  RunScriptsSummary<RunWorkspaceScriptMetadata>
+>;
+export type RunScriptAcrossWorkspacesProcessOutput = MultiProcessOutput<
+  RunWorkspaceScriptMetadata & {
+    streamName: OutputStreamName;
+  }
+> &
+  /** @deprecated */
+  SimpleAsyncIterable<RunScriptAcrossWorkspacesOutput>;
+/** Result of `FileSystemProject.runScriptAcrossWorkspaces` */
+export type RunScriptAcrossWorkspacesResult = {
+  output: RunScriptAcrossWorkspacesProcessOutput;
+  summary: Promise<RunScriptAcrossWorkspacesSummary>;
+};
 declare class _FileSystemProject extends ProjectBase implements Project {
   #private;
   readonly rootDirectory: string;