@package-pal/core 0.0.2 → 0.0.5

package/index.js

@@ -15,20 +15,19 @@ import { isDefined as isDefined5 } from "@package-pal/util";
 // packages/core/src/lib/configuration/functions/check-bun.ts
 var checkBun = () => {
   if (!Bun) {
-    throw new Error("This package must be run with the Bun runtime.");
+    throw new Error("This package must be run using the Bun runtime (see https://bun.com/).");
   }
 };
 
 // packages/core/src/lib/configuration/functions/load-config.ts
+import { styleText } from "util";
+import { dirname as dirname3 } from "path";
+import { cwd } from "process";
 import {
   deepMergeDefined,
   formatSimpleLogObject,
   noOp as noOp2
 } from "@package-pal/util";
-import {
-  bgGray,
-  dim
-} from "yoctocolors";
 
 // packages/core/src/lib/configuration/functions/get-default-logger.ts
 import {
@@ -94,6 +93,7 @@ var Config = z3.object({
   watch: z3.optional(zLooseObjectWithoutIndexSignature({
     debounceMs: z3.optional(z3.number()),
     hooks: z3.optional(z3.object({
+      onInit: z3.optional(zLooseFunction()),
       onBeforeProcessPackage: z3.optional(zLooseFunction()),
       onProcessPackage: z3.optional(zLooseFunction()),
       onProcessPackageError: z3.optional(zLooseFunction()),
@@ -104,9 +104,9 @@ var Config = z3.object({
     })),
     subprocess: z3.optional(z3.object({
       partialProcessing: z3.optional(z3.boolean()),
-      parallelProcessing: z3.optional(z3.boolean()),
-      matchLongRunningOutputAsReady: z3.nullish(z3.string()),
-      matchLongRunningOutputAsErrored: z3.nullish(z3.string())
+      concurrency: z3.nullish(z3.number()),
+      matchLongRunningOutputAsReady: z3.nullish(z3.union([z3.string(), z3.array(z3.string())])),
+      matchLongRunningOutputAsErrored: z3.nullish(z3.union([z3.string(), z3.array(z3.string())]))
     }))
   })),
   logLevel: z3.optional(LogLevel)
@@ -227,6 +227,7 @@ var defaultConfig = {
   watch: {
     debounceMs: 500,
     hooks: {
+      onInit: noOp2,
       onBeforeProcessPackage: noOp2,
       onProcessPackage: noOp2,
       onProcessPackageError: noOp2,
@@ -237,7 +238,7 @@ var defaultConfig = {
     },
     subprocess: {
       partialProcessing: false,
-      parallelProcessing: true,
+      concurrency: null,
       matchLongRunningOutputAsReady: null,
       matchLongRunningOutputAsErrored: null
     }
@@ -249,31 +250,48 @@ var loadConfig = async (overrideConfigPath) => {
   const path = await searchConfigPath(overrideConfigPath);
   if (!path) {
     defaultConfig.logger.info("No config file found. Defaults will be applied.");
-    return defaultConfig;
+    return {
+      config: defaultConfig,
+      rootDir: cwd()
+    };
   }
   const parsedConfig = await parseConfig(path);
   const parsedLogger = parsedConfig["logger"];
   const logger = parsedLogger ?? (!parsedConfig.logLevel || parsedConfig.logLevel === defaultConfig.logLevel ? defaultConfig.logger : getDefaultLogger(parsedConfig.logLevel));
-  logger.debug(dim(bgGray("User config:")), `
-${dim(formatSimpleLogObject(parsedConfig))}`);
-  logger.debug(dim(bgGray("Default config:")), `
-${dim(formatSimpleLogObject(defaultConfig))}`);
+  logger.debug(`Successfully loaded config file '${path}'.`);
+  logger.debug(styleText("dim", styleText("bgGray", "User config:")), `
+${styleText("dim", formatSimpleLogObject(parsedConfig))}`);
+  logger.debug(styleText("dim", styleText("bgGray", "Default config:")), `
+${styleText("dim", formatSimpleLogObject(defaultConfig))}`);
   const activatedConfig = deepMergeDefined(defaultConfig, parsedConfig);
   activatedConfig.logger = logger;
-  logger.debug(dim(bgGray("Activated config:")), `
-${dim(formatSimpleLogObject(activatedConfig))}`);
-  return activatedConfig;
+  logger.debug(styleText("dim", styleText("bgGray", "Activated config:")), `
+${styleText("dim", formatSimpleLogObject(activatedConfig))}`);
+  return {
+    config: activatedConfig,
+    rootDir: dirname3(path)
+  };
 };
 
 // packages/core/src/lib/graph/functions/generate-graphs.ts
+import { styleText as styleText2 } from "util";
 import { assertDefined as assertDefined2 } from "@package-pal/util";
-import { dim as dim2 } from "yoctocolors";
+
+// packages/core/src/lib/package/types/dependencies-field.ts
+var DependenciesField = {
+  Dependencies: "dependencies",
+  DevDependencies: "devDependencies",
+  PeerDependencies: "peerDependencies",
+  OptionalDependencies: "optionalDependencies"
+};
+
+// packages/core/src/lib/graph/functions/generate-graphs.ts
 var trackPackageEntryDependencies = ({
   trackedDependencies,
   packageNames,
   packageData
 }) => {
-  const iterateEntries = [packageData.dependencies, packageData.peerDependencies];
+  const iterateEntries = Object.values(DependenciesField).map((field) => packageData[field]);
   for (const packageEntries of iterateEntries) {
     if (!packageEntries) {
       continue;
@@ -301,7 +319,7 @@ var generateReverseGraph = (packages, packageGraph) => {
   return reversePackageGraph;
 };
 var generateGraphs = (packages, logger) => {
-  logger.debug(dim2(`Generating package graphs for ${packages.length.toString()} packages...`));
+  logger.debug(styleText2("dim", `Generating package graphs for ${packages.length.toString()} packages...`));
   const packageNames = new Set(packages.map((packageData) => packageData.name));
   const packageGraph = new Map;
   for (const packageData of packages) {
@@ -324,11 +342,8 @@ var generateGraphs = (packages, logger) => {
 };
 
 // packages/core/src/lib/graph/functions/generate-package-circular-dependency-paths.ts
+import { styleText as styleText3 } from "util";
 import { assertDefined as assertDefined6 } from "@package-pal/util";
-import {
-  dim as dim3,
-  yellow
-} from "yoctocolors";
 
 // packages/core/src/lib/graph/functions/dfs-traverse-graph-paths.ts
 import { assertDefined as assertDefined3 } from "@package-pal/util";
@@ -479,7 +494,7 @@ var findSampleCyclePath = (scc, graph) => {
   }));
 };
 var generatePackageCircularDependencyPaths = ({ dependents }, packageSorted, logger) => {
-  logger.debug(dim3("Generating circular dependency paths..."));
+  logger.debug(styleText3("dim", "Generating circular dependency paths..."));
   const subgraph = extractSubgraph(dependents, packageSorted.circular);
   const scss = findStronglyConnectedComponents(subgraph);
   const sampleCycles = scss.map((scc) => findSampleCyclePath(scc, subgraph).reverse());
@@ -488,20 +503,17 @@ var generatePackageCircularDependencyPaths = ({ dependents }, packageSorted, log
       return `	${(index + 1).toString()}. ` + cycle.map((name) => `'${name}'`).join(" \u2192 ");
     }).join(`
 `);
-    logger.warn(yellow(`${sampleCycles.length.toString()} cyclic paths found:
+    logger.warn(styleText3("yellow", `${sampleCycles.length.toString()} cyclic paths found:
 ${sampleCycleContents}`));
   } else {
-    logger.debug(dim3(`No cyclic paths found.`));
+    logger.debug(styleText3("dim", `No cyclic paths found.`));
   }
   return sampleCycles;
 };
 
 // packages/core/src/lib/graph/functions/generate-topological-sorted-groups.ts
+import { styleText as styleText4 } from "util";
 import { assertDefined as assertDefined7 } from "@package-pal/util";
-import {
-  dim as dim4,
-  yellow as yellow2
-} from "yoctocolors";
 var getCircularDependencies = (inDegree) => {
   return Array.from(inDegree.keys()).sort((a, b) => {
     const degA = assertDefined7(inDegree.get(a));
@@ -510,7 +522,7 @@ var getCircularDependencies = (inDegree) => {
   }).sort();
 };
 var generateTopologicalSortedGroups = (packageGraph, logger) => {
-  logger.debug(dim4("Generating topological sorted groups..."));
+  logger.debug(styleText4("dim", "Generating topological sorted groups..."));
   const graphEntries = Array.from(packageGraph.entries());
   const inDegree = new Map(graphEntries.map(([packageName]) => [packageName, 0]));
   const graph = new Map(graphEntries.map(([packageName]) => [packageName, new Set]));
@@ -545,10 +557,10 @@ var generateTopologicalSortedGroups = (packageGraph, logger) => {
     }
     ready = nextReady;
   }
-  logger.debug(dim4(`Sorted packages into ${result.length.toString()} sequential groups of parallelizable dependencies.`));
+  logger.debug(styleText4("dim", `Sorted packages into ${result.length.toString()} sequential groups of parallelizable dependencies.`));
   const circular = getCircularDependencies(inDegree);
   if (circular.length) {
-    logger.warn(yellow2(`${circular.length.toString()} packages could not be sorted due to circular dependencies. Correct ordering cannot be guaranteed.`));
+    logger.warn(styleText4("yellow", `${circular.length.toString()} packages could not be sorted due to circular dependencies. Correct ordering cannot be guaranteed.`));
   }
   return {
     groups: result.map((group) => group.sort()),
@@ -557,22 +569,19 @@ var generateTopologicalSortedGroups = (packageGraph, logger) => {
 };
 
 // packages/core/src/lib/package/functions/load-packages.ts
-import { dim as dim6 } from "yoctocolors";
+import { styleText as styleText6 } from "util";
 
 // packages/core/src/lib/package/functions/scan-packages.ts
+import { styleText as styleText5 } from "util";
 import {
-  dirname as dirname4,
+  dirname as dirname5,
   join as join2
 } from "path";
 import { formatUnknownError } from "@package-pal/util";
-import {
-  dim as dim5,
-  red
-} from "yoctocolors";
 
 // packages/core/src/lib/package/functions/parse-package.ts
 import {
-  dirname as dirname3,
+  dirname as dirname4,
   basename as basename2
 } from "path";
 import { isDefined as isDefined2 } from "@package-pal/util";
@@ -587,14 +596,17 @@ var parsePackage = (path, text) => {
     peerDependencies,
     devDependencies
   } = props;
-  if (isDefined2(dependencies) && !(typeof dependencies === "object") || isDefined2(peerDependencies) && !(typeof peerDependencies === "object") || isDefined2(devDependencies) && !(typeof devDependencies === "object")) {
-    return;
+  for (const field of Object.values(DependenciesField)) {
+    const value = props[field];
+    if (isDefined2(value) && typeof value !== "object") {
+      return;
+    }
   }
   return {
     rawContent: text,
     path,
     name: props.name ?? path,
-    dir: basename2(dirname3(path)),
+    dir: basename2(dirname4(path)),
     version: props.version ?? undefined,
     dependencies: dependencies ?? undefined,
     peerDependencies: peerDependencies ?? undefined,
@@ -604,41 +616,51 @@ var parsePackage = (path, text) => {
 
 // packages/core/src/lib/package/functions/scan-package-paths.ts
 import { scanGlobPatternPaths } from "@package-pal/util";
-var scanPackagePaths = (packages) => {
-  return scanGlobPatternPaths(packages, {
+var scanPackagePaths = (packages, cwd2) => {
+  const baseOpts = {
     absolute: true,
     onlyFiles: false
-  });
+  };
+  const opts = {
+    ...baseOpts,
+    ...cwd2 ? { cwd: cwd2 } : {}
+  };
+  return scanGlobPatternPaths(packages, opts);
 };
 
 // packages/core/src/lib/package/functions/scan-packages.ts
-var scanPackages = async function* (patterns, logger) {
-  for await (const path of scanPackagePaths(patterns)) {
+var scanPackages = async function* (patterns, logger, cwd2) {
+  for await (const path of scanPackagePaths(patterns, cwd2)) {
     const packagePath = join2(path, "package.json");
-    const dir = dirname4(packagePath);
+    const dir = dirname5(packagePath);
     try {
+      logger.debug(styleText5("dim", `Trying to read read package.json in '${dir}'.`));
       const file = Bun.file(packagePath);
+      if (!file.size) {
+        logger.debug(styleText5("dim", `Failed to read package.json in '${dir}' - ${styleText5("red", "File not found")}.`));
+        continue;
+      }
       const text = await file.text();
       const packageData = parsePackage(packagePath, text);
       if (!packageData) {
-        logger.debug(dim5(`Invalid package.json found in '${dir}'.`));
+        logger.debug(styleText5("dim", `Invalid package.json found in '${dir}'.`));
         continue;
       }
-      logger.debug(dim5(`Successfully read package.json in '${dir}'.`));
+      logger.debug(styleText5("dim", `Successfully read package.json in '${dir}'.`));
       yield packageData;
     } catch (e) {
-      logger.debug(dim5(`Failed to read package.json in '${dir}' - ${red(formatUnknownError(e))}.`));
+      logger.debug(styleText5("dim", `Failed to read package.json in '${dir}' - ${styleText5("red", formatUnknownError(e))}.`));
     }
   }
 };
 
 // packages/core/src/lib/package/functions/load-packages.ts
-var loadPackages = async (packagePatterns, logger) => {
+var loadPackages = async (rootDir, packagePatterns, logger) => {
   const patternContent = packagePatterns.map((pattern) => `'${pattern}'`).join(", ");
-  logger.debug(dim6(`Loading packages matching pattern/s ${patternContent}...`));
+  logger.debug(styleText6("dim", `Loading packages matching pattern/s ${patternContent}...${rootDir ? ` from ${rootDir}` : ""}`));
   const packages = [];
   const seen = new Set;
-  for await (const packageData of scanPackages(Array.from(new Set(packagePatterns)), logger)) {
+  for await (const packageData of scanPackages(Array.from(new Set(packagePatterns)), logger, rootDir)) {
     if (seen.has(packageData.name)) {
       continue;
     }
@@ -651,10 +673,282 @@ var loadPackages = async (packagePatterns, logger) => {
   return packages;
 };
 
+// packages/core/src/lib/package/functions/run-for-each-package.ts
+import { dirname as dirname6 } from "path";
+import {
+  assertDefined as assertDefined9,
+  runAsync
+} from "@package-pal/util";
+
+// packages/core/src/lib/process/functions/run-subprocess.ts
+import { styleText as styleText7 } from "util";
+
+// packages/core/src/lib/process/types/exit-state.ts
+var ExitState = {
+  Completed: "Completed",
+  Errored: "Errored",
+  Cancelled: "Cancelled"
+};
+
+// packages/core/src/lib/process/types/std-type.ts
+var StdType = {
+  Out: "Out",
+  Err: "Err"
+};
+
+// packages/core/src/lib/process/functions/get-commands-for-shell.ts
+import {
+  escapeShellArg,
+  getShell,
+  Shell
+} from "@package-pal/util";
+
+// packages/core/src/lib/process/functions/parse-ps-flags.ts
+import { assertDefined as assertDefined8 } from "@package-pal/util";
+var knownFlagsWithParams = new Set([
+  "-executionpolicy",
+  "-windowstyle",
+  "-version",
+  "-file",
+  "-inputformat",
+  "-outputformat",
+  "-workingdirectory",
+  "-psconsolefile",
+  "-pshome",
+  "-configurationname",
+  "-argumentlist",
+  "-warningaction",
+  "-erroraction",
+  "-informationaction",
+  "-informationvariable",
+  "-warningvariable",
+  "-errorvariable",
+  "-outvariable",
+  "-outbuffer",
+  "-throttlelimit",
+  "-culture",
+  "-uiculture"
+]);
+var knownFlagsNoParams = new Set([
+  "-noprofile",
+  "-noninteractive",
+  "-nologo",
+  "-sta",
+  "-mta",
+  "-encodedcommand",
+  "-command",
+  "-help",
+  "-?",
+  "-verbose",
+  "-debug",
+  "-whatif",
+  "-confirm",
+  "-usewindowspowershell",
+  "-noexit"
+]);
+var parsePsFlags = (input) => {
+  const tokens = input.trim().split(/\s+/);
+  const flags = [];
+  let i = 0;
+  while (i < tokens.length) {
+    const token = assertDefined8(tokens[i]);
+    const tokenLower = token.toLowerCase();
+    if (knownFlagsWithParams.has(tokenLower)) {
+      if (i + 1 >= tokens.length) {
+        break;
+      }
+      flags.push(token, assertDefined8(tokens[i + 1]));
+      i += 2;
+      continue;
+    }
+    if (knownFlagsNoParams.has(tokenLower)) {
+      flags.push(token);
+      i += 1;
+      continue;
+    }
+    break;
+  }
+  const command = tokens.slice(i).join(" ");
+  return {
+    flags,
+    command
+  };
+};
+
+// packages/core/src/lib/process/functions/get-commands-for-shell.ts
+var shell;
+var getCommandsForShell = (shellCommand) => {
+  shell = shell ?? getShell();
+  switch (shell) {
+    case Shell.cmd:
+      return [
+        shell,
+        "/c",
+        escapeShellArg(shellCommand, shell)
+      ];
+    case Shell.pwsh:
+    case Shell.powershell:
+      const {
+        flags,
+        command
+      } = parsePsFlags(shellCommand);
+      const encodedCommand = Buffer.from(command, "utf16le").toString("base64");
+      return [
+        shell,
+        ...flags,
+        ...encodedCommand ? ["-EncodedCommand", encodedCommand] : []
+      ];
+    default:
+      return [
+        shell,
+        "-c",
+        escapeShellArg(shellCommand, shell)
+      ];
+  }
+};
+
+// packages/core/src/lib/process/functions/get-line-buffered-writer.ts
+import { identity } from "@package-pal/util";
+var getLineBufferedWriter = (prefix, style = identity, write = process.stdout.write.bind(process.stdout)) => {
+  let buffer = "";
+  return (chunk) => {
+    buffer += chunk;
+    const lines = buffer.split(`
+`);
+    buffer = lines.pop() ?? "";
+    for (const line of lines) {
+      write(`${prefix}${style(line)}
+`);
+    }
+  };
+};
+
+// packages/core/src/lib/process/functions/read-stream.ts
+var readStream = async (stream, use) => {
+  const decoder = new TextDecoder;
+  const reader = stream.getReader();
+  let result = await reader.read();
+  while (!result.done) {
+    use(decoder.decode(result.value, { stream: true }));
+    result = await reader.read();
+  }
+  const flush = decoder.decode();
+  if (flush) {
+    use(flush);
+  }
+};
+
+// packages/core/src/lib/process/functions/run-subprocess.ts
+var sigintCode = 130;
+var sigtermCode = 143;
+var sigkillCode = 137;
+var cancelCodes = new Set([
+  sigintCode,
+  sigtermCode,
+  sigkillCode
+]);
+var runSubprocess = async (opts) => {
+  if (opts.signal?.aborted) {
+    opts.logger.debug(styleText7("dim", `Skipped '${opts.debugName}' subprocess command; signal already cancelled.`));
+    return ExitState.Cancelled;
+  }
+  const commands = getCommandsForShell(opts.shellCommand);
+  const baseSubprocessOpts = {
+    stdout: "pipe",
+    stderr: "pipe",
+    stdin: "ignore"
+  };
+  const subprocessOpts = {
+    ...baseSubprocessOpts,
+    ...opts.cwd ? { cwd: opts.cwd } : {},
+    ...opts.signal ? { signal: opts.signal } : {}
+  };
+  const subprocess = Bun.spawn(commands, subprocessOpts);
+  const pid = subprocess.pid.toString();
+  const minPrefixLen = 14;
+  const [readStdout, readStderr] = [{
+    source: subprocess.stdout,
+    type: StdType.Out,
+    write: getLineBufferedWriter(styleText7("dim", `[O-${pid}]`.padEnd(minPrefixLen, " ")))
+  }, {
+    source: subprocess.stderr,
+    type: StdType.Err,
+    write: getLineBufferedWriter(styleText7("yellow", styleText7("dim", `[E-${pid}]`.padEnd(minPrefixLen, " "))))
+  }].map(({
+    source,
+    type,
+    write
+  }) => {
+    return readStream(source, (chunk) => {
+      write(chunk);
+      if (opts.onStdChunk) {
+        opts.onStdChunk(chunk, type);
+      }
+    });
+  });
+  const executedCommand = commands.join(" ");
+  opts.logger.debug(styleText7("dim", `Started '${opts.debugName}' subprocess command '${opts.shellCommand}' (${executedCommand}) with PID ${pid}.`));
+  const [
+    ,
+    ,
+    exitState
+  ] = await Promise.all([
+    readStdout,
+    readStderr,
+    subprocess.exited.then((exitCode) => {
+      if (cancelCodes.has(exitCode)) {
+        opts.logger.debug(styleText7("dim", `Cancelled '${opts.debugName}' subprocess command; PID ${pid} exited.`));
+        return ExitState.Cancelled;
+      }
+      if (exitCode !== 0) {
+        opts.logger.error(styleText7("red", `'${opts.debugName}' command '${opts.shellCommand}' (${executedCommand}) with PID ${pid} failed with exit code ${exitCode.toString()}.`));
+        return ExitState.Errored;
+      }
+      opts.logger.debug(styleText7("dim", `Completed '${opts.debugName}' subprocess command; PID ${pid} exited.`));
+      return ExitState.Completed;
+    })
+  ]);
+  return exitState;
+};
+
+// packages/core/src/lib/package/functions/run-for-each-package.ts
+var runForEachPackage = async (packageGraphs, packageOrder, getCommand, logger, topological = true, concurrency) => {
+  const controller = new AbortController;
+  let processPackageOrder = packageOrder.groups.concat(packageOrder.circular);
+  if (!topological) {
+    processPackageOrder = [processPackageOrder.flat()];
+  }
+  for (const group of processPackageOrder) {
+    await runAsync(group.map((packageName) => async () => {
+      const packageNode = assertDefined9(packageGraphs.dependencies.get(packageName));
+      const processPackageProps = {
+        name: packageName,
+        dir: packageNode.packageData.dir
+      };
+      const processPackageCwd = dirname6(packageNode.packageData.path);
+      const shellCommand = await getCommand(processPackageProps);
+      if (!shellCommand) {
+        return;
+      }
+      const exitState = await runSubprocess({
+        debugName: `run for ${packageName}`,
+        shellCommand,
+        cwd: processPackageCwd,
+        signal: controller.signal,
+        logger
+      });
+      if (exitState === ExitState.Errored) {
+        controller.abort();
+        throw new Error("Command failed.");
+      }
+    }), concurrency);
+  }
+};
+
 // packages/core/src/lib/package/functions/update-package-version.ts
+import { styleText as styleText8 } from "util";
 var {semver } = globalThis.Bun;
 import { inc } from "semver";
-import { dim as dim7 } from "yoctocolors";
 var findAndReplaceVersion = ({
   raw,
   field,
@@ -714,7 +1008,7 @@ var findAndReplaceVersion = ({
   return `${before}${updatedVersion}${after}`;
 };
 var updatePackageVersion = async (packageName, type, packageGraphs, preId, exact, logger) => {
-  logger.debug(dim7(`Bumping package '${packageName}'...`));
+  logger.debug(styleText8("dim", `Bumping package '${packageName}'...`));
   const packageNode = packageGraphs.dependencies.get(packageName);
   if (!packageNode) {
     throw new Error(`Package '${packageName}' not found.`);
@@ -738,15 +1032,14 @@ var updatePackageVersion = async (packageName, type, packageGraphs, preId, exact
   });
   const baseWrite = Bun.write(packageNode.packageData.path, updatedContent);
   const dependentWrites = Array.from(dfsTraverseGraph(packageGraphs.dependents, packageName).flatMap((dependent) => {
-    const fields = ["dependencies", "peerDependencies"];
-    return fields.flatMap((field) => {
+    return Object.values(DependenciesField).flatMap((field) => {
       const entry = dependent[field];
       const depVersion = entry?.[packageName];
       if (!depVersion) {
         return [];
       }
       if (exact ? depVersion === bumpedVersion : semver.satisfies(bumpedVersion, depVersion)) {
-        logger.debug(dim7(`Skipping '${dependent.name}': ${field} version '${depVersion}' already satisfies '${bumpedVersion}'.`));
+        logger.debug(styleText8("dim", `Skipping '${dependent.name}': ${field} version '${depVersion}' already satisfies '${bumpedVersion}'.`));
         return [];
       }
       const updatedContent2 = findAndReplaceVersion({
@@ -770,22 +1063,57 @@ var updatePackageVersion = async (packageName, type, packageGraphs, preId, exact
 import {
   watch
 } from "fs";
+import { styleText as styleText10 } from "util";
 import {
-  dirname as dirname6,
+  dirname as dirname8,
   join as join4
 } from "path";
 import {
-  assertDefined as assertDefined9,
+  assertDefined as assertDefined12,
   DedupePathsBy,
   dedupeSharedPaths,
   getDeferredPromise,
   getStringMatcher,
-  isDefined as isDefined4
+  isDefined as isDefined4,
+  runAsync as runAsync2
 } from "@package-pal/util";
-import {
-  dim as dim9,
-  red as red3
-} from "yoctocolors";
+
+// packages/core/src/lib/graph/functions/merge-graphs.ts
+var mergeGraphs = (a, b) => {
+  const merged = new Map;
+  for (const [name, node] of a) {
+    merged.set(name, {
+      packageData: node.packageData,
+      pointsToPackages: new Set(node.pointsToPackages)
+    });
+  }
+  for (const [name, node] of b) {
+    merged.set(name, {
+      packageData: node.packageData,
+      pointsToPackages: new Set(node.pointsToPackages)
+    });
+  }
+  return merged;
+};
+
+// packages/core/src/lib/watch/types/change-action.ts
+var ChangeAction = {
+  Ignore: "Ignore",
+  Partial: "Partial",
+  Restart: "Restart"
+};
+
+// packages/core/src/lib/watch/functions/filter-files-modified-since.ts
+var filterFilesModifiedSince = (paths, sinceMs) => {
+  return paths.filter((path) => {
+    const changedFile = Bun.file(path);
+    return changedFile.lastModified >= sinceMs;
+  });
+};
+
+// packages/core/src/lib/watch/functions/get-change-logic.ts
+import { styleText as styleText9 } from "util";
+import { assertDefined as assertDefined11 } from "@package-pal/util";
 
 // packages/core/src/lib/graph/functions/generate-topological-ranking-range.ts
 import { isDefined as isDefined3 } from "@package-pal/util";
@@ -811,11 +1139,11 @@ var generateTopologicalRankingRange = (graph, ranking) => {
 };
 
 // packages/core/src/lib/graph/functions/generate-topological-ranking.ts
-import { assertDefined as assertDefined8 } from "@package-pal/util";
+import { assertDefined as assertDefined10 } from "@package-pal/util";
 var generateTopologicalRanking = (packageProcessOrder) => {
   const rankMap = new Map;
   for (let i = 0;i < packageProcessOrder.length; i++) {
-    for (const packageName of assertDefined8(packageProcessOrder[i])) {
+    for (const packageName of assertDefined10(packageProcessOrder[i])) {
       rankMap.set(packageName, i);
     }
   }
@@ -880,225 +1208,13 @@ var isSubgraph = (a, b) => {
   return true;
 };
 
-// packages/core/src/lib/watch/types/change-action.ts
-var ChangeAction = {
-  Ignore: "Ignore",
-  Partial: "Partial",
-  Restart: "Restart"
-};
-
-// packages/core/src/lib/watch/types/exit-state.ts
-var ExitState = {
-  Completed: "Completed",
-  Errored: "Errored",
-  Cancelled: "Cancelled"
-};
-
-// packages/core/src/lib/watch/types/run-async-type.ts
-var RunAsyncType = {
-  Sequential: "Sequential",
-  Parallel: "Parallel"
-};
-
-// packages/core/src/lib/watch/functions/filter-files-modified-since.ts
-var filterFilesModifiedSince = (paths, sinceMs) => {
-  return paths.filter((path) => {
-    const changedFile = Bun.file(path);
-    return changedFile.lastModified >= sinceMs;
-  });
-};
-
-// packages/core/src/lib/watch/functions/normalise-watched-file-path.ts
-import {
-  basename as basename3,
-  dirname as dirname5,
-  join as join3
-} from "path";
-var removeTrailing = [
-  "~",
-  ".tmp",
-  ".temp",
-  ".bak",
-  ".backup",
-  ".swp",
-  ".swo",
-  ".swn"
-];
-var normaliseWatchedFilePath = (filePath) => {
-  const dir = dirname5(filePath);
-  let base = basename3(filePath);
-  for (const trailing of removeTrailing) {
-    if (base.toLowerCase().endsWith(trailing)) {
-      const sliceStart = base.startsWith(".") ? 1 : 0;
-      base = base.slice(sliceStart, -trailing.length);
-      break;
-    }
-  }
-  return join3(dir, base);
-};
-
-// packages/core/src/lib/watch/functions/run-async.ts
-var runAsync = async (type, tasks) => {
-  if (type === RunAsyncType.Parallel) {
-    return Promise.all(tasks.map((task) => task()));
-  }
-  const outputs = [];
-  for (const task of tasks) {
-    const result = await task();
-    outputs.push(result);
-  }
-  return outputs;
-};
-
-// packages/core/src/lib/watch/functions/run-subprocess.ts
-import {
-  dim as dim8,
-  red as red2
-} from "yoctocolors";
-
-// packages/core/src/lib/watch/types/std-type.ts
-var StdType = {
-  Out: "Out",
-  Err: "Err"
-};
-
-// packages/core/src/lib/watch/functions/get-commands-for-shell.ts
-var getCommandsForShell = (shellCommand) => {
-  const isWindows = process.platform === "win32";
-  if (!isWindows) {
-    return [
-      "sh",
-      "-c",
-      `"${shellCommand}"`
-    ];
-  }
-  const shell = Bun.which("pwsh") ? "pwsh" : Bun.which("powershell") ? "powershell" : "cmd";
-  if (shell === "cmd") {
-    return [
-      shell,
-      "/c",
-      `"${shellCommand}"`
-    ];
-  }
-  const encodedCommand = Buffer.from(shellCommand, "utf16le").toString("base64");
-  return [
-    shell,
-    "-EncodedCommand",
-    encodedCommand
-  ];
-};
-
-// packages/core/src/lib/watch/functions/get-line-buffered-writer.ts
-import { identity } from "@package-pal/util";
-var getLineBufferedWriter = (prefix, style = identity, write = process.stdout.write.bind(process.stdout)) => {
-  let buffer = "";
-  return (chunk) => {
-    buffer += chunk;
-    const lines = buffer.split(`
-`);
-    buffer = lines.pop() ?? "";
-    for (const line of lines) {
-      write(`${prefix}${style(line)}
-`);
-    }
-  };
-};
-
-// packages/core/src/lib/watch/functions/read-stream.ts
-var readStream = async (stream, use) => {
-  if (!stream) {
-    return;
-  }
-  const decoder = new TextDecoder;
-  const reader = stream.getReader();
-  let result = await reader.read();
-  while (!result.done) {
-    use(decoder.decode(result.value, { stream: true }));
-    result = await reader.read();
-  }
-  const flush = decoder.decode();
-  if (flush) {
-    use(flush);
-  }
-};
-
-// packages/core/src/lib/watch/functions/run-subprocess.ts
-var sigintCode = 130;
-var sigtermCode = 143;
-var sigkillCode = 137;
-var cancelCodes = new Set([
-  sigintCode,
-  sigtermCode,
-  sigkillCode
-]);
-var runSubprocess = async (opts) => {
-  if (opts.signal?.aborted) {
-    opts.logger.debug(dim8(`Skipped '${opts.debugName}' subprocess command; signal already cancelled.`));
-    return ExitState.Cancelled;
-  }
-  const commands = getCommandsForShell(opts.shellCommand);
-  const subprocess = Bun.spawn(commands, {
-    cwd: opts.cwd,
-    stdout: "pipe",
-    stderr: "pipe",
-    stdin: "ignore",
-    signal: opts.signal
-  });
-  const pid = subprocess.pid.toString();
-  const [readStdout, readStderr] = [{
-    source: subprocess.stdout,
-    type: StdType.Out,
-    write: getLineBufferedWriter(dim8(`[OUT-${pid}]	`))
-  }, {
-    source: subprocess.stderr,
-    type: StdType.Err,
-    write: getLineBufferedWriter(red2(dim8(`[ERR-${pid}]	`)))
-  }].map(({
-    source,
-    type,
-    write
-  }) => {
-    return readStream(source, (chunk) => {
-      write(chunk);
-      if (opts.onStdChunk) {
-        opts.onStdChunk(chunk, type);
-      }
-    });
-  });
-  const executedCommand = commands.join(" ");
-  opts.logger.debug(dim8(`Started '${opts.debugName}' subprocess command '${opts.shellCommand}' (${executedCommand}) with PID ${pid}.`));
-  const [
-    ,
-    ,
-    exitState
-  ] = await Promise.all([
-    readStdout,
-    readStderr,
-    subprocess.exited.then((exitCode) => {
-      if (cancelCodes.has(exitCode)) {
-        opts.logger.debug(dim8(`Cancelled '${opts.debugName}' subprocess command; PID ${pid} exited.`));
-        return ExitState.Cancelled;
-      }
-      if (exitCode !== 0) {
-        opts.logger.error(red2(`'${opts.debugName}' command '${opts.shellCommand}' (${executedCommand}) with PID ${pid} failed with exit code ${exitCode.toString()}.`));
-        return ExitState.Errored;
-      }
-      opts.logger.debug(dim8(`Completed '${opts.debugName}' subprocess command; PID ${pid} exited.`));
-      return ExitState.Completed;
-    })
-  ]);
-  return exitState;
-};
-
-// packages/core/src/lib/watch/functions/watch-package-changes.ts
-var fileModifiedThresholdMs = 5000;
-var lastProcessedSubgraph;
-var getChangeLogic = (packageGraphs, packageChanges, config, logger) => {
+// packages/core/src/lib/watch/functions/get-change-logic.ts
+var getChangeLogic = (packageGraphs, packageChanges, lastProcessedSubgraph, config, logger) => {
   const changedPackages = Array.from(packageChanges.keys());
   const changedFilePaths = Array.from(packageChanges.values()).flat();
   if (packageChanges.size) {
-    logger.debug(dim9(`Changes detected in ${changedPackages.map((packageName) => `'${packageName}'`).join(", ")}.`));
-    logger.debug(dim9(`Changed file paths: ${changedFilePaths.map((filePath) => `'${filePath}'`).join(", ")}.`));
+    logger.debug(styleText9("dim", `Changes detected in ${changedPackages.map((packageName) => `'${packageName}'`).join(", ")}.`));
+    logger.debug(styleText9("dim", `Changed file paths: ${changedFilePaths.map((filePath) => `'${filePath}'`).join(", ")}.`));
   }
   const packageOrder = generateTopologicalSortedGroups(packageGraphs.dependents, logger);
   const packageProcessOrder = packageOrder.groups.toReversed().concat(packageOrder.circular);
@@ -1109,9 +1225,9 @@ var getChangeLogic = (packageGraphs, packageChanges, config, logger) => {
   const isSubgraphOfPrevious = !!lastProcessedSubgraph && isSubgraph(lastProcessedSubgraph, changedPackageSubgraph);
   const isDisjointFromPrevious = !lastProcessedSubgraph || !isSubgraphOfPrevious && isDisjoint(lastProcessedSubgraph, changedPackageSubgraph);
   const isRankedGreaterThanOrEqualToPrevious = !!lastProcessedSubgraph && !isSubgraphOfPrevious && isRankedGreaterThanOrEqual(lastProcessedSubgraph, changedPackageSubgraph, packageRankings);
-  logger.debug(dim9(`Changes are subgraph of previous: ${isSubgraphOfPrevious.toString()}.`));
-  logger.debug(dim9(`Changes are disjoint from previous: ${isDisjointFromPrevious.toString()}.`));
-  logger.debug(dim9(`Changes are ranked greater than or equal to previous: ${isRankedGreaterThanOrEqualToPrevious.toString()}.`));
+  logger.debug(styleText9("dim", `Changes are subgraph of previous: ${isSubgraphOfPrevious.toString()}.`));
+  logger.debug(styleText9("dim", `Changes are disjoint from previous: ${isDisjointFromPrevious.toString()}.`));
+  logger.debug(styleText9("dim", `Changes are ranked greater than or equal to previous: ${isRankedGreaterThanOrEqualToPrevious.toString()}.`));
   let action = ChangeAction.Restart;
   if (!packageChanges.size) {
     action = ChangeAction.Ignore;
@@ -1123,30 +1239,64 @@ var getChangeLogic = (packageGraphs, packageChanges, config, logger) => {
     action = ChangeAction.Partial;
   }
   if (action === ChangeAction.Partial && isRankedGreaterThanOrEqualToPrevious) {
-    const [prevMinRank] = generateTopologicalRankingRange(assertDefined9(lastProcessedSubgraph), packageRankings);
+    const [prevMinRank] = generateTopologicalRankingRange(assertDefined11(lastProcessedSubgraph), packageRankings);
     for (let i = 0;i < changedPackageProcessOrder.length; i++) {
-      changedPackageProcessOrder[i] = assertDefined9(changedPackageProcessOrder[i]).filter((packageName) => {
+      changedPackageProcessOrder[i] = assertDefined11(changedPackageProcessOrder[i]).filter((packageName) => {
         const rank = packageRankings.get(packageName);
         return rank !== undefined && rank >= prevMinRank;
       });
     }
   }
-  logger.debug(dim9(`Determined change action: ${action}.`));
+  logger.debug(styleText9("dim", `Determined change action: ${action}.`));
   return {
     changedPackageProcessOrder,
     changedPackageSubgraph,
     action
   };
 };
+
+// packages/core/src/lib/watch/functions/normalise-watched-file-path.ts
+import {
+  basename as basename3,
+  dirname as dirname7,
+  join as join3
+} from "path";
+var removeTrailing = [
+  "~",
+  ".tmp",
+  ".temp",
+  ".bak",
+  ".backup",
+  ".swp",
+  ".swo",
+  ".swn"
+];
+var normaliseWatchedFilePath = (filePath) => {
+  const dir = dirname7(filePath);
+  let base = basename3(filePath);
+  for (const trailing of removeTrailing) {
+    if (base.toLowerCase().endsWith(trailing)) {
+      const sliceStart = base.startsWith(".") ? 1 : 0;
+      base = base.slice(sliceStart, -trailing.length);
+      break;
+    }
+  }
+  return join3(dir, base);
+};
+
+// packages/core/src/lib/watch/functions/watch-package-changes.ts
+var fileModifiedThresholdMs = 5000;
+var lastProcessedSubgraph;
 var onProcessPackage = async (packageGraphs, packageChanges, watchConfig, determineAbortController, logger) => {
   const {
     action,
     changedPackageProcessOrder,
     changedPackageSubgraph
-  } = getChangeLogic(packageGraphs, packageChanges, watchConfig, logger);
+  } = getChangeLogic(packageGraphs, packageChanges, lastProcessedSubgraph, watchConfig, logger);
   const controller = determineAbortController(action === ChangeAction.Restart);
+  const isSequential = watchConfig.subprocess.concurrency === 1;
   const onProcessFailure = () => {
-    logger.debug(dim9("Aborting controller: process failed."));
+    logger.debug(styleText10("dim", "Aborting controller: process failed."));
     controller.abort();
     lastProcessedSubgraph = undefined;
   };
@@ -1155,8 +1305,8 @@ var onProcessPackage = async (packageGraphs, packageChanges, watchConfig, determ
     return;
   }
   if (packageChanges.size) {
-    logger.info(`Changes detected. ${action === ChangeAction.Restart ? "Restarting processing" : "Initiating partial processing"} ${watchConfig.subprocess.parallelProcessing ? "in parallel" : "sequentially"}.`);
-    lastProcessedSubgraph = changedPackageSubgraph;
+    logger.info(`${action === ChangeAction.Restart ? "Restarting processing" : "Initiating partial processing"} ${isSequential ? "sequentially" : `in parallel${isDefined4(watchConfig.subprocess.concurrency) ? ` with concurrency ${watchConfig.subprocess.concurrency.toString()}` : ""}`}.`);
+    lastProcessedSubgraph = lastProcessedSubgraph ? mergeGraphs(lastProcessedSubgraph, changedPackageSubgraph) : changedPackageSubgraph;
   }
   for (const group of changedPackageProcessOrder) {
     const {
@@ -1164,12 +1314,12 @@ var onProcessPackage = async (packageGraphs, packageChanges, watchConfig, determ
       resolve: matchedParallelLongReadyRunningOutput
     } = getDeferredPromise();
     let matchedLongRunningOutputCount = 0;
-    await runAsync(watchConfig.subprocess.parallelProcessing ? RunAsyncType.Parallel : RunAsyncType.Sequential, group.map((packageName) => async () => {
+    await runAsync2(group.map((packageName) => async () => {
       const {
         promise: longRunningSequentialProcessReady,
         resolve: matchedSequentialLongRunningReadyOutput
       } = getDeferredPromise();
-      const packageNode = assertDefined9(packageGraphs.dependencies.get(packageName));
+      const packageNode = assertDefined12(packageGraphs.dependencies.get(packageName));
       const changedPaths = packageChanges.get(packageName) ?? [];
       const processPackageProps = {
         name: packageName,
@@ -1179,7 +1329,7 @@ var onProcessPackage = async (packageGraphs, packageChanges, watchConfig, determ
         totalProcessOrder: changedPackageProcessOrder,
         signal: controller.signal
       };
-      const processPackageCwd = dirname6(packageNode.packageData.path);
+      const processPackageCwd = dirname8(packageNode.packageData.path);
       const beforeProcessPackageShellCommand = await watchConfig.hooks.onBeforeProcessPackage(processPackageProps);
       if (beforeProcessPackageShellCommand) {
         await runSubprocess({
@@ -1205,36 +1355,42 @@ var onProcessPackage = async (packageGraphs, packageChanges, watchConfig, determ
           signal: controller.signal,
           logger,
           onStdChunk: (chunk) => {
-            if (!ready && readyMatcher?.push(chunk).matched()) {
-              ready = true;
-              matchedLongRunningOutputCount++;
-              logger.debug(`'${packageName}' (${matchedLongRunningOutputCount.toString()}/${group.length.toString()}) subprocess matched ready text '${assertDefined9(longRunningOutputReadyText)}'.`);
-              if (!watchConfig.subprocess.parallelProcessing && matchedLongRunningOutputCount) {
-                matchedSequentialLongRunningReadyOutput();
+            if (!ready) {
+              const matchedReadyText = readyMatcher?.push(chunk).matched();
+              if (matchedReadyText) {
+                ready = true;
+                matchedLongRunningOutputCount++;
+                logger.debug(`'${packageName}' (${matchedLongRunningOutputCount.toString()}/${group.length.toString()}) subprocess matched ready text '${matchedReadyText}'.`);
+                if (isSequential && matchedLongRunningOutputCount) {
+                  matchedSequentialLongRunningReadyOutput();
+                }
               }
             }
-            if (!errored && erroredMatcher?.push(chunk).matched()) {
-              logger.error(red3(`'${packageName}' subprocess matched error text '${assertDefined9(longRunningOutputErroredText)}'.`));
-              errored = true;
-              Promise.resolve(watchConfig.hooks.onProcessPackageError(processPackageProps)).then((processPackageErrorCommand) => {
-                if (!processPackageErrorCommand) {
-                  onProcessFailure();
-                  return;
-                }
-                return runSubprocess({
-                  debugName: `after process ${packageName}`,
-                  shellCommand: processPackageErrorCommand,
-                  cwd: processPackageCwd,
-                  signal: controller.signal,
-                  logger
+            if (!errored) {
+              const matchedErrorText = erroredMatcher?.push(chunk).matched();
+              if (matchedErrorText) {
+                logger.error(styleText10("red", `'${packageName}' subprocess matched error text '${matchedErrorText}'.`));
+                errored = true;
+                Promise.resolve(watchConfig.hooks.onProcessPackageError(processPackageProps)).then((processPackageErrorCommand) => {
+                  if (!processPackageErrorCommand) {
+                    onProcessFailure();
+                    return;
+                  }
+                  return runSubprocess({
+                    debugName: `after process ${packageName}`,
+                    shellCommand: processPackageErrorCommand,
+                    cwd: processPackageCwd,
+                    signal: controller.signal,
+                    logger
+                  });
+                }).then((exitState) => {
+                  if (exitState === ExitState.Errored) {
+                    onProcessFailure();
+                  }
                 });
-              }).then((exitState) => {
-                if (exitState === ExitState.Errored) {
-                  onProcessFailure();
-                }
-              });
+              }
             }
-            if (watchConfig.subprocess.parallelProcessing && matchedLongRunningOutputCount === group.length) {
+            if (!isSequential && matchedLongRunningOutputCount === group.length) {
               matchedParallelLongReadyRunningOutput();
             }
           }
@@ -1259,7 +1415,7 @@ var onProcessPackage = async (packageGraphs, packageChanges, watchConfig, determ
           logger
         });
       }
-    }));
+    }), watchConfig.subprocess.concurrency);
   }
   if (packageChanges.size) {
     logger.info(`Processing ${controller.signal.aborted ? "cancelled due to new changes" : "completed"}.`);
@@ -1296,26 +1452,31 @@ var onProcessPackage = async (packageGraphs, packageChanges, watchConfig, determ
     });
   }
 };
-var watchPackageChanges = (packageData, packageGraphs, watchConfig, logger) => {
-  const dedupedRootPackageData = dedupeSharedPaths(packageData.map((packageData2) => packageData2.path), DedupePathsBy.Parent).map((packagePath) => assertDefined9(packageData.find((data) => data.path === packagePath)));
-  logger.debug(dim9(`Starting ${dedupedRootPackageData.length.toString()} watchers for ${packageData.length.toString()} packages.`));
+var watchPackageChanges = (packageData, packageGraphs, watchConfig, rootDir, logger) => {
+  const dedupedRootPackageData = dedupeSharedPaths(packageData.map((packageData2) => packageData2.path), DedupePathsBy.Parent).map((packagePath) => assertDefined12(packageData.find((data) => data.path === packagePath)));
+  logger.debug(styleText10("dim", `Starting ${dedupedRootPackageData.length.toString()} watchers for ${packageData.length.toString()} packages.`));
   let closed = false;
   let debounceTimeout;
   let startedDebounceMs;
-  let abortController;
+  let controller;
   const changedPackagePaths = new Map;
   const useController = (reset) => {
-    if (abortController && (reset || abortController.signal.aborted)) {
+    if (controller && (reset || controller.signal.aborted)) {
       if (reset) {
-        logger.debug(dim9("Aborting controller: reset for new packages."));
-        abortController.abort();
+        logger.debug(styleText10("dim", "Aborting controller: reset for new packages."));
+        controller.abort();
       }
-      abortController = undefined;
+      controller = undefined;
     }
-    abortController ??= new AbortController;
-    return abortController;
+    controller ??= new AbortController;
+    return controller;
   };
-  const onWatchEvent = (watchPath, packageName, _event, filePath, forceEmpty = false) => {
+  const onWatchEvent = ({
+    watchPath,
+    packageName,
+    filePath,
+    isInitial = false
+  }) => {
     if (!isDefined4(startedDebounceMs)) {
       startedDebounceMs = Date.now();
     }
@@ -1331,54 +1492,72 @@ var watchPackageChanges = (packageData, packageGraphs, watchConfig, logger) => {
         changedPackagePaths.set(packageName, new Set([changedPath]));
       }
     }
+    const debounceMs = isInitial ? 0 : watchConfig.debounceMs;
     debounceTimeout = setTimeout(() => {
       if (closed) {
         return;
       }
       const packageChanges = new Map;
       for (const [packageName2, paths] of changedPackagePaths) {
-        const processedPaths = filterFilesModifiedSince(dedupeSharedPaths(Array.from(paths), DedupePathsBy.Child).sort(), assertDefined9(startedDebounceMs) - fileModifiedThresholdMs);
+        const dedupedPaths = dedupeSharedPaths(Array.from(paths), DedupePathsBy.Child).sort();
+        const processedPaths = filterFilesModifiedSince(dedupedPaths, assertDefined12(startedDebounceMs) - fileModifiedThresholdMs);
         if (processedPaths.length) {
           packageChanges.set(packageName2, processedPaths);
         }
       }
       startedDebounceMs = undefined;
       changedPackagePaths.clear();
-      if (!packageChanges.size && !forceEmpty) {
+      if (!packageChanges.size && !isInitial) {
         return;
       }
       onProcessPackage(packageGraphs, packageChanges, watchConfig, (reset) => useController(reset), logger);
-    }, watchConfig.debounceMs);
+    }, debounceMs);
   };
   const watchers = dedupedRootPackageData.map(({
     name,
     path
   }) => {
-    const watchPath = dirname6(path);
+    const watchPath = dirname8(path);
     return watch(watchPath, { recursive: true }, (event, filePath) => {
-      onWatchEvent(watchPath, name, event, filePath);
+      onWatchEvent({
+        watchPath,
+        packageName: name,
+        event,
+        filePath: filePath ?? undefined
+      });
     });
   });
   const closeWatchers = () => {
     watchers.forEach((watcher) => {
       watcher.close();
     });
-    logger.debug(dim9("Aborting controller: closing watchers."));
-    abortController?.abort();
+    logger.debug(styleText10("dim", "Aborting controller: closing watchers."));
+    controller?.abort();
     closed = true;
   };
   process.on("SIGINT", () => {
-    logger.debug(dim9("Received SIGINT: closing watchers."));
+    logger.debug(styleText10("dim", "Received SIGINT: closing watchers."));
     closeWatchers();
     process.exit(0);
   });
-  onWatchEvent(undefined, undefined, undefined, null, true);
+  Promise.resolve(watchConfig.hooks.onInit()).then(async (onInitShellCommand) => {
+    if (onInitShellCommand) {
+      await runSubprocess({
+        debugName: `on init`,
+        shellCommand: onInitShellCommand,
+        signal: useController(false).signal,
+        cwd: rootDir,
+        logger
+      });
+    }
+    onWatchEvent({ isInitial: true });
+  });
   return { close: () => {
     if (closed) {
-      logger.debug(dim9("Watchers already closed."));
+      logger.debug(styleText10("dim", "Watchers already closed."));
       return;
     }
-    logger.debug(dim9("Closing watchers."));
+    logger.debug(styleText10("dim", "Closing watchers."));
     closeWatchers();
   } };
 };
@@ -1391,7 +1570,7 @@ var readPackagePalConfig = (options) => {
 var readPackageData = async (options) => {
   checkBun();
   const packagePatterns = Array.isArray(options.config.packages) ? options.config.packages : [options.config.packages];
-  return loadPackages(packagePatterns, options.config.logger);
+  return loadPackages(options.rootDir, packagePatterns, options.config.logger);
 };
 var getPackageGraphs = (options) => {
   checkBun();
@@ -1413,7 +1592,11 @@ var bumpPackageVersion = (options) => {
 };
 var watchPackages = (options) => {
   checkBun();
-  watchPackageChanges(options.packageData, options.packageGraphs, options.config.watch, options.config.logger);
+  watchPackageChanges(options.packageData, options.packageGraphs, options.config.watch, options.rootDir, options.config.logger);
+};
+var forEachPackage = (options) => {
+  checkBun();
+  return runForEachPackage(options.packageGraphs, options.packageOrder, options.getCommand, options.config.logger, options.topological, options.concurrency);
 };
 export {
   watchPackages,
@@ -1422,9 +1605,10 @@ export {
   getPackageOrder,
   getPackageGraphs,
   getPackageCircularDependencyPaths,
+  forEachPackage,
   bumpPackageVersion,
   BumpVersionType
 };
 
-//# debugId=038CF7D68B032DA664756E2164756E21
+//# debugId=57C320DF799C435664756E2164756E21
 //# sourceMappingURL=index.js.map