@package-pal/core 0.0.3 → 0.0.7

package/index.js

@@ -15,11 +15,12 @@ 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 {
@@ -27,10 +28,6 @@ import {
   formatSimpleLogObject,
   noOp as noOp2
 } from "@package-pal/util";
-import {
-  bgGray,
-  dim
-} from "yoctocolors";
 
 // packages/core/src/lib/configuration/functions/get-default-logger.ts
 import {
@@ -95,7 +92,9 @@ var Config = z3.object({
   })),
   watch: z3.optional(zLooseObjectWithoutIndexSignature({
     debounceMs: z3.optional(z3.number()),
+    ignore: z3.optional(z3.union([z3.string(), z3.array(z3.string())])),
     hooks: z3.optional(z3.object({
+      onInit: z3.optional(zLooseFunction()),
       onBeforeProcessPackage: z3.optional(zLooseFunction()),
       onProcessPackage: z3.optional(zLooseFunction()),
       onProcessPackageError: z3.optional(zLooseFunction()),
@@ -106,9 +105,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)
@@ -228,7 +227,9 @@ var defaultConfig = {
   },
   watch: {
     debounceMs: 500,
+    ignore: "",
     hooks: {
+      onInit: noOp2,
       onBeforeProcessPackage: noOp2,
       onProcessPackage: noOp2,
       onProcessPackageError: noOp2,
@@ -239,7 +240,7 @@ var defaultConfig = {
     },
     subprocess: {
       partialProcessing: false,
-      parallelProcessing: true,
+      concurrency: null,
       matchLongRunningOutputAsReady: null,
       matchLongRunningOutputAsErrored: null
     }
@@ -260,14 +261,14 @@ var loadConfig = async (overrideConfigPath) => {
   const parsedLogger = parsedConfig["logger"];
   const logger = parsedLogger ?? (!parsedConfig.logLevel || parsedConfig.logLevel === defaultConfig.logLevel ? defaultConfig.logger : getDefaultLogger(parsedConfig.logLevel));
   logger.debug(`Successfully loaded config file '${path}'.`);
-  logger.debug(dim(bgGray("User config:")), `
-${dim(formatSimpleLogObject(parsedConfig))}`);
-  logger.debug(dim(bgGray("Default config:")), `
-${dim(formatSimpleLogObject(defaultConfig))}`);
+  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))}`);
+  logger.debug(styleText("dim", styleText("bgGray", "Activated config:")), `
+${styleText("dim", formatSimpleLogObject(activatedConfig))}`);
   return {
     config: activatedConfig,
     rootDir: dirname3(path)
@@ -275,14 +276,24 @@ ${dim(formatSimpleLogObject(activatedConfig))}`);
 };
 
 // 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;
@@ -310,7 +321,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) {
@@ -333,11 +344,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";
@@ -488,7 +496,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());
@@ -497,20 +505,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));
@@ -519,7 +524,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]));
@@ -554,10 +559,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()),
@@ -566,18 +571,15 @@ 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 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 {
@@ -596,8 +598,11 @@ 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,
@@ -614,11 +619,15 @@ var parsePackage = (path, text) => {
 // packages/core/src/lib/package/functions/scan-package-paths.ts
 import { scanGlobPatternPaths } from "@package-pal/util";
 var scanPackagePaths = (packages, cwd2) => {
-  return scanGlobPatternPaths(packages, {
+  const baseOpts = {
     absolute: true,
-    onlyFiles: false,
-    cwd: cwd2
-  });
+    onlyFiles: false
+  };
+  const opts = {
+    ...baseOpts,
+    ...cwd2 ? { cwd: cwd2 } : {}
+  };
+  return scanGlobPatternPaths(packages, opts);
 };
 
 // packages/core/src/lib/package/functions/scan-packages.ts
@@ -627,22 +636,22 @@ var scanPackages = async function* (patterns, logger, cwd2) {
     const packagePath = join2(path, "package.json");
     const dir = dirname5(packagePath);
     try {
-      logger.debug(dim5(`Trying to read read package.json in '${dir}'.`));
+      logger.debug(styleText5("dim", `Trying to read read package.json in '${dir}'.`));
       const file = Bun.file(packagePath);
       if (!file.size) {
-        logger.debug(dim5(`Failed to read package.json in '${dir}' - ${red("File not found")}.`));
+        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))}.`));
     }
   }
 };
@@ -650,7 +659,7 @@ var scanPackages = async function* (patterns, logger, cwd2) {
 // packages/core/src/lib/package/functions/load-packages.ts
 var loadPackages = async (rootDir, packagePatterns, logger) => {
   const patternContent = packagePatterns.map((pattern) => `'${pattern}'`).join(", ");
-  logger.debug(dim6(`Loading packages matching pattern/s ${patternContent}...${rootDir ? ` from ${rootDir}` : ""}`));
+  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, rootDir)) {
@@ -670,15 +679,11 @@ var loadPackages = async (rootDir, packagePatterns, logger) => {
 import { dirname as dirname6 } from "path";
 import {
   assertDefined as assertDefined9,
-  runAsync,
-  RunAsyncType
+  runAsync
 } from "@package-pal/util";
 
 // packages/core/src/lib/process/functions/run-subprocess.ts
-import {
-  dim as dim7,
-  red as red2
-} from "yoctocolors";
+import { styleText as styleText7 } from "util";
 
 // packages/core/src/lib/process/types/exit-state.ts
 var ExitState = {
@@ -700,82 +705,57 @@ import {
   Shell
 } from "@package-pal/util";
 
-// packages/core/src/lib/process/functions/parse-ps-flags.ts
+// packages/core/src/lib/process/functions/parse-ps-shell-flags.ts
 import { assertDefined as assertDefined8 } from "@package-pal/util";
-var knownFlagsWithParams = new Set([
+var shellFlagsWithParams = new Set([
   "-executionpolicy",
   "-windowstyle",
-  "-version",
-  "-file",
-  "-inputformat",
-  "-outputformat",
-  "-workingdirectory",
-  "-psconsolefile",
-  "-pshome",
-  "-configurationname",
-  "-argumentlist",
-  "-warningaction",
-  "-erroraction",
-  "-informationaction",
-  "-informationvariable",
-  "-warningvariable",
-  "-errorvariable",
-  "-outvariable",
-  "-outbuffer",
-  "-throttlelimit",
-  "-culture",
-  "-uiculture"
+  "-version"
 ]);
-var knownFlagsNoParams = new Set([
+var shellFlagsNoParams = new Set([
   "-noprofile",
   "-noninteractive",
-  "-nologo",
   "-sta",
   "-mta",
-  "-encodedcommand",
-  "-command",
+  "-nologo",
   "-help",
   "-?",
-  "-verbose",
-  "-debug",
-  "-whatif",
-  "-confirm",
-  "-usewindowspowershell",
-  "-noexit"
+  "-noexit",
+  "-usewindowspowerShell"
 ]);
-var parsePsFlags = (input) => {
-  const tokens = input.trim().split(/\s+/);
-  const flags = [];
+var parsePsShellFlags = (input) => {
+  const isPreEncoded = input.toLowerCase().includes("-encodedcommand");
+  const tokens = input.match(/"[^"]*"|'[^']*'|\S+/g) ?? [];
+  const flags = new Set;
   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;
+    if (shellFlagsWithParams.has(tokenLower)) {
+      flags.add(token);
+      if (i + 1 < tokens.length) {
+        flags.add(assertDefined8(tokens[i + 1]));
+        i++;
       }
-      flags.push(token, assertDefined8(tokens[i + 1]));
-      i += 2;
-      continue;
-    }
-    if (knownFlagsNoParams.has(tokenLower)) {
-      flags.push(token);
-      i += 1;
-      continue;
+      i++;
+    } else if (shellFlagsNoParams.has(tokenLower)) {
+      flags.add(token);
+      i++;
+    } else {
+      break;
     }
-    break;
   }
   const command = tokens.slice(i).join(" ");
   return {
     flags,
-    command
+    command,
+    isPreEncoded
   };
 };
 
 // packages/core/src/lib/process/functions/get-commands-for-shell.ts
-var shell;
 var getCommandsForShell = (shellCommand) => {
-  shell = shell ?? getShell();
+  const shell = getShell();
   switch (shell) {
     case Shell.cmd:
       return [
@@ -787,9 +767,13 @@ var getCommandsForShell = (shellCommand) => {
     case Shell.powershell:
       const {
         flags,
-        command
-      } = parsePsFlags(shellCommand);
-      const encodedCommand = Buffer.from(command, "utf16le").toString("base64");
+        command,
+        isPreEncoded
+      } = parsePsShellFlags(shellCommand);
+      if (isPreEncoded) {
+        return [shell, shellCommand];
+      }
+      const encodedCommand = Buffer.from(command || " ", "utf16le").toString("base64");
       return [
         shell,
         ...flags,
@@ -822,9 +806,6 @@ var getLineBufferedWriter = (prefix, style = identity, write = process.stdout.wr
 
 // packages/core/src/lib/process/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();
@@ -849,27 +830,31 @@ var cancelCodes = new Set([
 ]);
 var runSubprocess = async (opts) => {
   if (opts.signal?.aborted) {
-    opts.logger.debug(dim7(`Skipped '${opts.debugName}' subprocess command; signal already cancelled.`));
+    opts.logger.debug(styleText7("dim", `Skipped '${opts.debugName}' subprocess command; signal already cancelled.`));
     return ExitState.Cancelled;
   }
   const commands = getCommandsForShell(opts.shellCommand);
-  const subprocess = Bun.spawn(commands, {
-    cwd: opts.cwd,
+  const baseSubprocessOpts = {
     stdout: "pipe",
     stderr: "pipe",
-    stdin: "ignore",
-    signal: opts.signal
-  });
+    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(dim7(`[O-${pid}]`.padEnd(minPrefixLen, " ")))
+    write: getLineBufferedWriter(styleText7("dim", `[O-${pid}]`.padEnd(minPrefixLen, " ")))
   }, {
     source: subprocess.stderr,
     type: StdType.Err,
-    write: getLineBufferedWriter(red2(dim7(`[E-${pid}]`.padEnd(minPrefixLen, " "))))
+    write: getLineBufferedWriter(styleText7("yellow", styleText7("dim", `[E-${pid}]`.padEnd(minPrefixLen, " "))))
   }].map(({
     source,
     type,
@@ -883,7 +868,7 @@ var runSubprocess = async (opts) => {
     });
   });
   const executedCommand = commands.join(" ");
-  opts.logger.debug(dim7(`Started '${opts.debugName}' subprocess command '${opts.shellCommand}' (${executedCommand}) with PID ${pid}.`));
+  opts.logger.debug(styleText7("dim", `Started '${opts.debugName}' subprocess command '${opts.shellCommand}' (${executedCommand}) with PID ${pid}.`));
   const [
     ,
     ,
@@ -893,14 +878,14 @@ var runSubprocess = async (opts) => {
     readStderr,
     subprocess.exited.then((exitCode) => {
       if (cancelCodes.has(exitCode)) {
-        opts.logger.debug(dim7(`Cancelled '${opts.debugName}' subprocess command; PID ${pid} exited.`));
+        opts.logger.debug(styleText7("dim", `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()}.`));
+        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(dim7(`Completed '${opts.debugName}' subprocess command; PID ${pid} exited.`));
+      opts.logger.debug(styleText7("dim", `Completed '${opts.debugName}' subprocess command; PID ${pid} exited.`));
       return ExitState.Completed;
     })
   ]);
@@ -908,14 +893,14 @@ var runSubprocess = async (opts) => {
 };
 
 // packages/core/src/lib/package/functions/run-for-each-package.ts
-var runForEachPackage = async (packageGraphs, packageOrder, getCommand, parallel, topological, logger) => {
+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(parallel ? RunAsyncType.Parallel : RunAsyncType.Sequential, group.map((packageName) => async () => {
+    await runAsync(group.map((packageName) => async () => {
       const packageNode = assertDefined9(packageGraphs.dependencies.get(packageName));
       const processPackageProps = {
         name: packageName,
@@ -937,14 +922,14 @@ var runForEachPackage = async (packageGraphs, packageOrder, getCommand, parallel
         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 dim8 } from "yoctocolors";
 var findAndReplaceVersion = ({
   raw,
   field,
@@ -1004,7 +989,7 @@ var findAndReplaceVersion = ({
   return `${before}${updatedVersion}${after}`;
 };
 var updatePackageVersion = async (packageName, type, packageGraphs, preId, exact, logger) => {
-  logger.debug(dim8(`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.`);
@@ -1028,15 +1013,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(dim8(`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({
@@ -1060,6 +1044,7 @@ var updatePackageVersion = async (packageName, type, packageGraphs, preId, exact
 import {
   watch
 } from "fs";
+import { styleText as styleText10 } from "util";
 import {
   dirname as dirname8,
   join as join4
@@ -1071,13 +1056,9 @@ import {
   getDeferredPromise,
   getStringMatcher,
   isDefined as isDefined4,
-  RunAsyncType as RunAsyncType2,
   runAsync as runAsync2
 } from "@package-pal/util";
-import {
-  dim as dim10,
-  red as red3
-} from "yoctocolors";
+var {Glob } = globalThis.Bun;
 
 // packages/core/src/lib/graph/functions/merge-graphs.ts
 var mergeGraphs = (a, b) => {
@@ -1113,8 +1094,8 @@ var filterFilesModifiedSince = (paths, 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";
-import { dim as dim9 } from "yoctocolors";
 
 // packages/core/src/lib/graph/functions/generate-topological-ranking-range.ts
 import { isDefined as isDefined3 } from "@package-pal/util";
@@ -1214,8 +1195,8 @@ var getChangeLogic = (packageGraphs, packageChanges, lastProcessedSubgraph, conf
   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);
@@ -1226,9 +1207,9 @@ var getChangeLogic = (packageGraphs, packageChanges, lastProcessedSubgraph, conf
   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;
@@ -1248,7 +1229,7 @@ var getChangeLogic = (packageGraphs, packageChanges, lastProcessedSubgraph, conf
       });
     }
   }
-  logger.debug(dim9(`Determined change action: ${action}.`));
+  logger.debug(styleText9("dim", `Determined change action: ${action}.`));
   return {
     changedPackageProcessOrder,
     changedPackageSubgraph,
@@ -1256,6 +1237,11 @@ var getChangeLogic = (packageGraphs, packageChanges, lastProcessedSubgraph, conf
   };
 };
 
+// packages/core/src/lib/watch/functions/normalise-pattern-separators.ts
+var normalisePatternSeparators = (path) => {
+  return path.replace(/\\/g, "/");
+};
+
 // packages/core/src/lib/watch/functions/normalise-watched-file-path.ts
 import {
   basename as basename3,
@@ -1294,9 +1280,11 @@ var onProcessPackage = async (packageGraphs, packageChanges, watchConfig, determ
     changedPackageProcessOrder,
     changedPackageSubgraph
   } = getChangeLogic(packageGraphs, packageChanges, lastProcessedSubgraph, watchConfig, logger);
-  const controller = determineAbortController(action === ChangeAction.Restart);
+  const isRestart = action === ChangeAction.Restart;
+  const isSequential = watchConfig.subprocess.concurrency === 1;
+  const controller = determineAbortController(isRestart);
   const onProcessFailure = () => {
-    logger.debug(dim10("Aborting controller: process failed."));
+    logger.debug(styleText10("dim", "Aborting controller: process failed."));
     controller.abort();
     lastProcessedSubgraph = undefined;
   };
@@ -1305,8 +1293,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 = lastProcessedSubgraph ? mergeGraphs(lastProcessedSubgraph, changedPackageSubgraph) : changedPackageSubgraph;
+    logger.info(`${isRestart ? "Restarting processing" : "Initiating partial processing"} ${isSequential ? "sequentially" : `in parallel${isDefined4(watchConfig.subprocess.concurrency) ? ` with concurrency ${watchConfig.subprocess.concurrency.toString()}` : ""}`}.`);
+    lastProcessedSubgraph = lastProcessedSubgraph && !isRestart ? mergeGraphs(lastProcessedSubgraph, changedPackageSubgraph) : changedPackageSubgraph;
   }
   for (const group of changedPackageProcessOrder) {
     const {
@@ -1314,7 +1302,7 @@ var onProcessPackage = async (packageGraphs, packageChanges, watchConfig, determ
       resolve: matchedParallelLongReadyRunningOutput
     } = getDeferredPromise();
     let matchedLongRunningOutputCount = 0;
-    await runAsync2(watchConfig.subprocess.parallelProcessing ? RunAsyncType2.Parallel : RunAsyncType2.Sequential, group.map((packageName) => async () => {
+    await runAsync2(group.map((packageName) => async () => {
       const {
         promise: longRunningSequentialProcessReady,
         resolve: matchedSequentialLongRunningReadyOutput
@@ -1355,36 +1343,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 '${assertDefined12(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 '${assertDefined12(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();
             }
           }
@@ -1409,7 +1403,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"}.`);
@@ -1446,18 +1440,19 @@ var onProcessPackage = async (packageGraphs, packageChanges, watchConfig, determ
     });
   }
 };
-var watchPackageChanges = (packageData, packageGraphs, watchConfig, logger) => {
+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(dim10(`Starting ${dedupedRootPackageData.length.toString()} watchers for ${packageData.length.toString()} packages.`));
+  logger.debug(styleText10("dim", `Starting ${dedupedRootPackageData.length.toString()} watchers for ${packageData.length.toString()} packages.`));
   let closed = false;
   let debounceTimeout;
   let startedDebounceMs;
   let controller;
+  const ignoreGlobs = watchConfig.ignore ? (Array.isArray(watchConfig.ignore) ? watchConfig.ignore : [watchConfig.ignore]).map((pattern) => new Glob(pattern)) : undefined;
   const changedPackagePaths = new Map;
   const useController = (reset) => {
     if (controller && (reset || controller.signal.aborted)) {
       if (reset) {
-        logger.debug(dim10("Aborting controller: reset for new packages."));
+        logger.debug(styleText10("dim", "Aborting controller: reset for new packages."));
         controller.abort();
       }
       controller = undefined;
@@ -1465,7 +1460,12 @@ var watchPackageChanges = (packageData, packageGraphs, watchConfig, logger) => {
     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();
     }
@@ -1473,7 +1473,11 @@ var watchPackageChanges = (packageData, packageGraphs, watchConfig, logger) => {
       clearTimeout(debounceTimeout);
     }
     if (packageName && watchPath && filePath) {
-      const changedPath = join4(watchPath, normaliseWatchedFilePath(filePath));
+      const changedPath = normalisePatternSeparators(join4(watchPath, normaliseWatchedFilePath(filePath)));
+      if (ignoreGlobs?.some((glob) => glob.match(changedPath))) {
+        logger.debug(styleText10("dim", `Ignoring change '${changedPath}' (matched ignore pattern).`));
+        return;
+      }
       const existingPaths = changedPackagePaths.get(packageName);
       if (existingPaths) {
         existingPaths.add(changedPath);
@@ -1481,24 +1485,26 @@ 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(), assertDefined12(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,
@@ -1506,29 +1512,45 @@ var watchPackageChanges = (packageData, packageGraphs, watchConfig, logger) => {
   }) => {
     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(dim10("Aborting controller: closing watchers."));
+    logger.debug(styleText10("dim", "Aborting controller: closing watchers."));
     controller?.abort();
     closed = true;
   };
   process.on("SIGINT", () => {
-    logger.debug(dim10("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(dim10("Watchers already closed."));
+      logger.debug(styleText10("dim", "Watchers already closed."));
       return;
     }
-    logger.debug(dim10("Closing watchers."));
+    logger.debug(styleText10("dim", "Closing watchers."));
     closeWatchers();
   } };
 };
@@ -1563,11 +1585,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.parallel ?? true, options.topological ?? true, options.config.logger);
+  return runForEachPackage(options.packageGraphs, options.packageOrder, options.getCommand, options.config.logger, options.topological, options.concurrency);
 };
 export {
   watchPackages,
@@ -1581,5 +1603,5 @@ export {
   BumpVersionType
 };
 
-//# debugId=F0FEFB088F7E727464756E2164756E21
+//# debugId=A9DE039F45717FA664756E2164756E21
 //# sourceMappingURL=index.js.map