@package-pal/core 0.0.9 → 0.0.12

package/index.js

@@ -9,9 +9,9 @@ var BumpVersionType = {
   Prepatch: "prepatch",
   Prerelease: "prerelease"
 };
-// packages/core/src/lib/api.ts
-import { isDefined as isDefined5 } from "@package-pal/util";
-
+// packages/core/src/lib/package/types/package-adapter.ts
+class PackageAdapter {
+}
 // packages/core/src/lib/configuration/functions/check-bun.ts
 var checkBun = () => {
   if (!Bun) {
@@ -20,9 +20,9 @@ var checkBun = () => {
 };
 
 // packages/core/src/lib/configuration/functions/load-config.ts
-import { styleText } from "util";
 import { dirname as dirname3 } from "path";
 import { cwd } from "process";
+import { styleText } from "util";
 import {
   deepMergeDefined,
   formatSimpleLogObject,
@@ -85,6 +85,11 @@ var LogLevel = z3.enum([
   "silent"
 ]);
 var Config = z3.object({
+  adapter: z3.optional(z3.enum([
+    "package-json",
+    "msbuild",
+    "auto"
+  ])),
   packages: z3.optional(z3.union([z3.string(), z3.array(z3.string())])),
   version: z3.optional(z3.object({
     preId: z3.optional(z3.string()),
@@ -210,6 +215,7 @@ var searchConfigPath = async (pathOverride) => {
 
 // packages/core/src/lib/configuration/functions/load-config.ts
 var defaultConfig = {
+  adapter: "auto",
   packages: "packages/*",
   version: {
     preId: "",
@@ -241,7 +247,7 @@ var defaultConfig = {
 var loadConfig = async (overrideConfigPath) => {
   const path = await searchConfigPath(overrideConfigPath);
   if (!path) {
-    defaultConfig.logger.info("No config file found. Defaults will be applied.");
+    defaultConfig.logger.debug("No config file found. Defaults will be applied.");
     return {
       config: defaultConfig,
       rootDir: cwd()
@@ -268,39 +274,26 @@ ${styleText("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";
-
-// 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 = Object.values(DependenciesField).map((field) => packageData[field]);
-  for (const packageEntries of iterateEntries) {
-    if (!packageEntries) {
+  for (const trackPackageName of packageData.localDependencies ?? []) {
+    if (!packageNames.has(trackPackageName)) {
       continue;
     }
-    for (const trackPackageName of Object.keys(packageEntries)) {
-      if (!packageNames.has(trackPackageName)) {
-        continue;
-      }
-      trackedDependencies.add(trackPackageName);
-    }
+    trackedDependencies.add(trackPackageName);
   }
 };
 var generateReverseGraph = (packages, packageGraph) => {
-  const reversePackageGraph = new Map(packages.map((packageData) => [packageData.name, {
-    packageData,
-    pointsToPackages: new Set
-  }]));
+  const reversePackageGraph = new Map;
+  for (const packageData of packages) {
+    reversePackageGraph.set(packageData.name, {
+      packageData,
+      pointsToPackages: new Set
+    });
+  }
   for (const packageData of packages) {
     const packageNode = assertDefined2(packageGraph.get(packageData.name));
     for (const dependency of packageNode.pointsToPackages) {
@@ -339,7 +332,8 @@ import { assertDefined as assertDefined6 } from "@package-pal/util";
 
 // packages/core/src/lib/graph/functions/dfs-traverse-graph-paths.ts
 import { assertDefined as assertDefined3 } from "@package-pal/util";
-var dfsTraverseGraphPaths = function* (graph, traverseFromPackages) {
+var dfsTraverseGraphPaths = function* (graph, traverseFromPackages, options = {}) {
+  const { useGlobalVisited = true } = options;
   const globalVisited = new Set;
   const startPackages = Array.isArray(traverseFromPackages) ? traverseFromPackages : [traverseFromPackages];
   for (const start of startPackages) {
@@ -357,14 +351,14 @@ var dfsTraverseGraphPaths = function* (graph, traverseFromPackages) {
       if (localVisited.has(node)) {
         const idx = path.indexOf(node);
         if (idx !== -1) {
-          yield [...path.slice(idx), node];
+          yield path.slice(idx).concat(node);
         }
         continue;
       }
-      if (globalVisited.has(node)) {
+      if (useGlobalVisited && globalVisited.has(node)) {
         continue;
       }
-      const newPath = [...path, node];
+      const newPath = path.concat(node);
       const newLocalVisited = new Set(localVisited);
       newLocalVisited.add(node);
       const neighbours = graph.get(node)?.pointsToPackages;
@@ -382,7 +376,9 @@ var dfsTraverseGraphPaths = function* (graph, traverseFromPackages) {
       if (!pushed) {
         yield newPath;
       }
-      globalVisited.add(node);
+      if (useGlobalVisited) {
+        globalVisited.add(node);
+      }
     }
   }
 };
@@ -394,7 +390,7 @@ import { assertDefined as assertDefined5 } from "@package-pal/util";
 import { assertDefined as assertDefined4 } from "@package-pal/util";
 var dfsTraverseGraph = function* (graph, traverseFromPackages) {
   const visited = new Set;
-  const stack = Array.isArray(traverseFromPackages) ? [...traverseFromPackages] : [traverseFromPackages];
+  const stack = Array.isArray(traverseFromPackages) ? traverseFromPackages.slice() : [traverseFromPackages];
   while (stack.length) {
     const activePackage = assertDefined4(stack.pop());
     if (visited.has(activePackage)) {
@@ -420,7 +416,12 @@ var extractSubgraph = (graph, fromPackages) => {
   const subgraph = new Map;
   for (const packageName of reachablePackages) {
     const node = assertDefined5(graph.get(packageName));
-    const filteredNeighbours = new Set([...node.pointsToPackages].filter((dep) => reachablePackages.has(dep)));
+    const filteredNeighbours = new Set;
+    for (const dep of node.pointsToPackages) {
+      if (reachablePackages.has(dep)) {
+        filteredNeighbours.add(dep);
+      }
+    }
     subgraph.set(packageName, {
       packageData: node.packageData,
       pointsToPackages: filteredNeighbours
@@ -510,18 +511,28 @@ var getCircularDependencies = (inDegree) => {
   return Array.from(inDegree.keys()).sort((a, b) => {
     const degA = assertDefined7(inDegree.get(a));
     const degB = assertDefined7(inDegree.get(b));
-    return degB - degA;
-  }).sort();
+    if (degB !== degA) {
+      return degB - degA;
+    }
+    return a.localeCompare(b);
+  });
 };
 var generateTopologicalSortedGroups = (packageGraph, logger) => {
-  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]));
-  for (const [packageName, node] of graphEntries) {
+  logger?.debug(styleText4("dim", "Generating topological sorted groups..."));
+  const inDegree = new Map;
+  const graph = new Map;
+  for (const [packageName] of packageGraph) {
+    inDegree.set(packageName, 0);
+    graph.set(packageName, new Set);
+  }
+  for (const [packageName, node] of packageGraph) {
     for (const dependencyName of node.pointsToPackages) {
-      assertDefined7(graph.get(dependencyName)).add(packageName);
-      inDegree.set(packageName, assertDefined7(inDegree.get(packageName)) + 1);
+      const adj = graph.get(dependencyName);
+      if (adj) {
+        adj.add(packageName);
+      }
+      const currentDeg = inDegree.get(packageName) ?? 0;
+      inDegree.set(packageName, currentDeg + 1);
     }
   }
   const result = [];
@@ -549,10 +560,10 @@ var generateTopologicalSortedGroups = (packageGraph, logger) => {
     }
     ready = nextReady;
   }
-  logger.debug(styleText4("dim", `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(styleText4("yellow", `${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()),
@@ -560,105 +571,56 @@ var generateTopologicalSortedGroups = (packageGraph, logger) => {
   };
 };
 
-// packages/core/src/lib/package/functions/load-packages.ts
-import { styleText as styleText6 } from "util";
-
-// packages/core/src/lib/package/functions/scan-packages.ts
+// packages/core/src/lib/package/functions/bump-package-version.ts
 import { styleText as styleText5 } from "util";
-import {
-  dirname as dirname5,
-  join as join2
-} from "path";
-import { formatUnknownError } from "@package-pal/util";
-
-// packages/core/src/lib/package/functions/parse-package.ts
-import {
-  dirname as dirname4,
-  basename as basename2
-} from "path";
 import { isDefined as isDefined2 } from "@package-pal/util";
-var parsePackage = (path, text) => {
-  const base = JSON.parse(text);
-  if (!isDefined2(base) || typeof base !== "object") {
-    return;
-  }
-  const props = base;
+import { inc } from "semver";
+var bumpPackageVersion = async (options) => {
+  const exact = isDefined2(options.exact) ? options.exact : options.config.version.exact;
+  const preId = isDefined2(options.preId) ? options.preId : options.config.version.preId;
   const {
-    dependencies,
-    peerDependencies,
-    devDependencies
-  } = props;
-  for (const field of Object.values(DependenciesField)) {
-    const value = props[field];
-    if (isDefined2(value) && typeof value !== "object") {
-      return;
-    }
+    packageName,
+    type,
+    packageGraphs,
+    adapter,
+    config: { logger }
+  } = options;
+  logger.debug(styleText5("dim", `Bumping package '${packageName}'...`));
+  const packageNode = packageGraphs.dependencies.get(packageName);
+  if (!packageNode) {
+    throw new Error(`Package '${packageName}' not found.`);
   }
-  return {
-    rawContent: text,
-    path,
-    name: props.name ?? path,
-    dir: basename2(dirname4(path)),
-    version: props.version ?? undefined,
-    dependencies: dependencies ?? undefined,
-    peerDependencies: peerDependencies ?? undefined,
-    devDependencies: devDependencies ?? undefined
-  };
-};
-
-// packages/core/src/lib/package/functions/scan-glob-pattern-paths.ts
-import { mergeAsyncIters } from "@package-pal/util";
-var {Glob } = globalThis.Bun;
-var scanGlobPatternPaths = (patterns, options) => {
-  return mergeAsyncIters(patterns.map((pattern) => new Glob(pattern).scan(options)));
-};
-
-// packages/core/src/lib/package/functions/scan-package-paths.ts
-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, cwd2) {
-  for await (const path of scanPackagePaths(patterns, cwd2)) {
-    const packagePath = join2(path, "package.json");
-    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(styleText5("dim", `Invalid package.json found in '${dir}'.`));
-        continue;
+  const currentVersion = packageNode.packageData.version ?? "1.0.0";
+  const bumpedVersion = inc(currentVersion, type, undefined, preId);
+  if (!bumpedVersion) {
+    throw new Error(`Package '${packageName}' version '${currentVersion}' is invalid.`);
+  }
+  logger.info(`Updating '${packageName}' version: ${currentVersion} \u2192 ${bumpedVersion}.`);
+  await adapter.bumpOwnVersion(packageNode.packageData, bumpedVersion, logger);
+  const dependentWrites = [];
+  for (const dependent of dfsTraverseGraph(packageGraphs.dependents, packageName)) {
+    dependentWrites.push((async () => {
+      const updated = await adapter.bumpDependencyVersion(dependent, packageName, bumpedVersion, exact, logger);
+      if (updated) {
+        logger.debug(styleText5("dim", `Updated dependency '${packageName}' in '${dependent.name}'.`));
       }
-      logger.debug(styleText5("dim", `Successfully read package.json in '${dir}'.`));
-      yield packageData;
-    } catch (e) {
-      logger.debug(styleText5("dim", `Failed to read package.json in '${dir}' - ${styleText5("red", formatUnknownError(e))}.`));
-    }
+    })());
   }
+  await Promise.all(dependentWrites);
 };
 
 // packages/core/src/lib/package/functions/load-packages.ts
-var loadPackages = async (rootDir, packagePatterns, logger) => {
-  const patternContent = packagePatterns.map((pattern) => `'${pattern}'`).join(", ");
+import { styleText as styleText6 } from "util";
+var loadPackages = async (rootDir, packagePatterns, adapter, logger) => {
+  let resolvedPatterns = packagePatterns;
+  if (packagePatterns.length === 1 && packagePatterns[0] === "packages/*") {
+    resolvedPatterns = adapter.defaultPatterns;
+  }
+  const patternContent = resolvedPatterns.map((pattern) => `'${pattern}'`).join(", ");
   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)) {
+  for await (const packageData of adapter.scanPackages(Array.from(new Set(resolvedPatterns)), logger, rootDir)) {
     if (seen.has(packageData.name)) {
       continue;
     }
@@ -672,9 +634,9 @@ var loadPackages = async (rootDir, packagePatterns, logger) => {
 };
 
 // packages/core/src/lib/package/functions/run-for-each-package.ts
-import { dirname as dirname6 } from "path";
+import { dirname as dirname4 } from "path";
 import {
-  assertDefined as assertDefined9,
+  assertDefined as assertDefined8,
   runAsync
 } from "@package-pal/util";
 
@@ -694,12 +656,95 @@ var StdType = {
   Err: "Err"
 };
 
+// packages/core/src/lib/process/functions/get-commands-for-shell.ts
+import { identity } from "@package-pal/util";
+
+// packages/core/src/lib/types/shell.ts
+var Shell = {
+  sh: "sh",
+  bash: "bash",
+  zsh: "zsh",
+  pwsh: "pwsh",
+  fish: "fish",
+  powershell: "powershell",
+  cmd: "cmd"
+};
+
+// packages/core/src/lib/process/functions/get-shell.ts
+import { userInfo } from "os";
+import { basename as basename2 } from "path";
+import {
+  platform,
+  env
+} from "process";
+var cachedShell = null;
+var cacheShell = (shell) => {
+  cachedShell = shell;
+  return shell;
+};
+var mapShell = (shellPath) => {
+  if (!shellPath) {
+    return Shell.sh;
+  }
+  const name = basename2(shellPath).replace(/\.exe$/i, "").toLowerCase();
+  switch (name) {
+    case "bash":
+      return Shell.bash;
+    case "zsh":
+      return Shell.zsh;
+    case "fish":
+      return Shell.fish;
+    case "sh":
+      return Shell.sh;
+    default:
+      return Shell.sh;
+  }
+};
+var getShell = () => {
+  if (cachedShell !== null) {
+    return cachedShell;
+  }
+  if (env.ZSH_VERSION) {
+    return cacheShell(Shell.zsh);
+  }
+  if (env.BASH_VERSION) {
+    return cacheShell(Shell.bash);
+  }
+  if (env.FISH_VERSION) {
+    return cacheShell(Shell.fish);
+  }
+  const isWindows = platform === "win32";
+  if (isWindows) {
+    if ((env.MSYSTEM || env.MINGW_PREFIX) && Bun.which(Shell.bash)) {
+      return cacheShell(Shell.bash);
+    }
+    if (Bun.which(Shell.pwsh)) {
+      return cacheShell(Shell.pwsh);
+    }
+    if (Bun.which(Shell.powershell)) {
+      return cacheShell(Shell.powershell);
+    }
+    return cacheShell(Shell.cmd);
+  }
+  if (env.SHELL) {
+    return cacheShell(mapShell(env.SHELL));
+  }
+  try {
+    const userShell = userInfo().shell;
+    if (userShell) {
+      return cacheShell(mapShell(userShell));
+    }
+  } catch {}
+  return cacheShell(Shell.sh);
+};
+
 // packages/core/src/lib/process/functions/parse-ps-shell-flags.ts
-import { assertDefined as assertDefined8 } from "@package-pal/util";
 var shellFlagsWithParams = new Set([
   "-executionpolicy",
   "-windowstyle",
-  "-version"
+  "-version",
+  "-encodedcommand",
+  "-command"
 ]);
 var shellFlagsNoParams = new Set([
   "-noprofile",
@@ -713,92 +758,68 @@ var shellFlagsNoParams = new Set([
   "-usewindowspowerShell"
 ]);
 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 tokenRegex = /("[^"]*"|'[^']*'|\S+)/g;
+  let match;
+  while ((match = tokenRegex.exec(input)) !== null) {
+    const token = match[0];
     const tokenLower = token.toLowerCase();
     if (shellFlagsWithParams.has(tokenLower)) {
       flags.add(token);
-      if (i + 1 < tokens.length) {
-        flags.add(assertDefined8(tokens[i + 1]));
-        i++;
+      const nextMatch = tokenRegex.exec(input);
+      if (nextMatch) {
+        flags.add(nextMatch[0]);
       }
-      i++;
     } else if (shellFlagsNoParams.has(tokenLower)) {
       flags.add(token);
-      i++;
     } else {
-      break;
+      const isPreEncoded2 = Array.from(flags).some((flag) => flag.toLowerCase() === "-encodedcommand");
+      return {
+        flags,
+        command: input.slice(match.index),
+        isPreEncoded: isPreEncoded2
+      };
     }
   }
-  const command = tokens.slice(i).join(" ");
+  const isPreEncoded = Array.from(flags).some((flag) => flag.toLowerCase() === "-encodedcommand");
   return {
     flags,
-    command,
+    command: "",
     isPreEncoded
   };
 };
 
-// packages/core/src/lib/types/shell.ts
-var Shell = {
-  sh: "sh",
-  bash: "bash",
-  zsh: "zsh",
-  pwsh: "pwsh",
-  fish: "fish",
-  powershell: "powershell",
-  cmd: "cmd"
-};
-
-// packages/core/src/lib/process/functions/escape-shell-arg.ts
-var escapeShellArg = (value, shell) => {
-  switch (shell) {
-    case Shell.cmd: {
-      const escaped = value.replace(/\^/g, "^^^^").replace(/([&<>|()])/g, "^$1").replace(/!/g, "^^!").replace(/%/g, "%%%%");
-      return `"${escaped}"`;
+// packages/core/src/lib/process/functions/strip-clixml.ts
+var createClixmlStripper = () => {
+  let buffer = "";
+  return (chunk) => {
+    buffer += chunk;
+    if (!buffer.includes("<") && !buffer.includes("#< CLIXML")) {
+      const out = buffer;
+      buffer = "";
+      return out;
     }
-    case Shell.powershell:
-    case Shell.pwsh:
-      return `'${value.replace(/'/g, "''")}'`;
-    case Shell.sh:
-    case Shell.bash:
-    case Shell.zsh:
-    case Shell.fish:
-    default:
-      return `'${value.replace(/'/g, "'\\''")}'`;
-  }
-};
-
-// packages/core/src/lib/process/functions/get-shell.ts
-import {
-  platform,
-  env
-} from "process";
-var getShell = () => {
-  const isWindows = platform === "win32";
-  if (!isWindows) {
-    const envShell = (env.SHELL ?? "").toLowerCase();
-    switch (true) {
-      case envShell.includes("bash"):
-        return Shell.bash;
-      case envShell.includes("zsh"):
-        return Shell.zsh;
-      case envShell.includes("fish"):
-        return Shell.fish;
-      default:
-        return Shell.sh;
+    const hasClixmlHeader = buffer.includes("#< CLIXML");
+    const hasClixmlTags = /<Obj|S S="Error"|<\/Objs>/.test(buffer);
+    if (!hasClixmlHeader && !hasClixmlTags) {
+      const out = buffer;
+      buffer = "";
+      return out;
     }
-  }
-  if (Bun.which(Shell.pwsh)) {
-    return Shell.pwsh;
-  }
-  if (Bun.which(Shell.powershell)) {
-    return Shell.powershell;
-  }
-  return Shell.cmd;
+    buffer = buffer.replace(/#< CLIXML/g, "").replace(/<Obj S="progress"[\s\S]*?<\/Obj>/g, "");
+    let output = "";
+    buffer = buffer.replace(/<S S="Error">([\s\S]*?)<\/S>/g, (_, msg) => {
+      output += msg;
+      return "";
+    });
+    if (buffer.includes("</Objs>")) {
+      output += buffer.replace(/<[^>]+>/g, "");
+      buffer = "";
+    }
+    if (!output)
+      return "";
+    return output.replace(/_x([0-9A-F]{4})_/g, (_, hex) => String.fromCharCode(parseInt(hex, 16))).replace(/<[^>]+>/g, "");
+  };
 };
 
 // packages/core/src/lib/process/functions/get-commands-for-shell.ts
@@ -806,11 +827,14 @@ var getCommandsForShell = (shellCommand) => {
   const shell = getShell();
   switch (shell) {
     case Shell.cmd:
-      return [
-        shell,
-        "/c",
-        escapeShellArg(shellCommand, shell)
-      ];
+      return {
+        commands: [
+          shell,
+          "/c",
+          shellCommand
+        ],
+        stderrProcessor: identity
+      };
     case Shell.pwsh:
     case Shell.powershell:
       const {
@@ -819,35 +843,66 @@ var getCommandsForShell = (shellCommand) => {
         isPreEncoded
       } = parsePsShellFlags(shellCommand);
       if (isPreEncoded) {
-        return [shell, shellCommand];
+        return {
+          commands: [shell, ...flags],
+          stderrProcessor: createClixmlStripper()
+        };
       }
       const encodedCommand = Buffer.from(command || " ", "utf16le").toString("base64");
-      return [
-        shell,
-        ...flags,
-        ...encodedCommand ? ["-EncodedCommand", encodedCommand] : []
-      ];
+      return {
+        commands: [
+          shell,
+          ...flags,
+          ...encodedCommand ? ["-EncodedCommand", encodedCommand] : []
+        ],
+        stderrProcessor: createClixmlStripper()
+      };
     default:
-      return [
-        shell,
-        "-c",
-        escapeShellArg(shellCommand, shell)
-      ];
+      return {
+        commands: [
+          shell,
+          "-c",
+          shellCommand
+        ],
+        stderrProcessor: identity
+      };
   }
 };
 
 // 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)) => {
+import { identity as identity2 } from "@package-pal/util";
+var getLineBufferedWriter = (prefix, style = identity2, write = process.stdout.write.bind(process.stdout)) => {
   let buffer = "";
-  return (chunk) => {
-    buffer += chunk;
-    const lines = buffer.split(`
+  return {
+    write: (chunk) => {
+      if (chunk === null) {
+        if (buffer.length > 0) {
+          write(`${prefix}${style(buffer)}
+`);
+          buffer = "";
+        }
+        return;
+      }
+      buffer += chunk;
+      let start = 0;
+      let newlineIndex = buffer.indexOf(`
 `);
-    buffer = lines.pop() ?? "";
-    for (const line of lines) {
-      write(`${prefix}${style(line)}
+      while (newlineIndex !== -1) {
+        let end = newlineIndex;
+        if (end > start && buffer[end - 1] === "\r") {
+          end--;
+        }
+        const line = buffer.slice(start, end);
+        write(`${prefix}${style(line)}
 `);
+        start = newlineIndex + 1;
+        newlineIndex = buffer.indexOf(`
+`, start);
+      }
+      buffer = buffer.slice(start);
+    },
+    flush() {
+      this.write(null);
     }
   };
 };
@@ -856,10 +911,14 @@ var getLineBufferedWriter = (prefix, style = identity, write = process.stdout.wr
 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();
+  try {
+    let result = await reader.read();
+    while (!result.done) {
+      use(decoder.decode(result.value, { stream: true }));
+      result = await reader.read();
+    }
+  } finally {
+    reader.releaseLock();
   }
   const flush = decoder.decode();
   if (flush) {
@@ -878,14 +937,21 @@ var cancelCodes = new Set([
 ]);
 var runSubprocess = async (opts) => {
   if (opts.signal?.aborted) {
-    opts.logger.debug(styleText7("dim", `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 {
+    commands,
+    stderrProcessor
+  } = getCommandsForShell(opts.shellCommand);
   const baseSubprocessOpts = {
     stdout: "pipe",
     stderr: "pipe",
-    stdin: "ignore"
+    stdin: "ignore",
+    env: {
+      ...process.env,
+      ...opts.env
+    }
   };
   const subprocessOpts = {
     ...baseSubprocessOpts,
@@ -898,25 +964,30 @@ var runSubprocess = async (opts) => {
   const [readStdout, readStderr] = [{
     source: subprocess.stdout,
     type: StdType.Out,
-    write: getLineBufferedWriter(styleText7("dim", `[O-${pid}]`.padEnd(minPrefixLen, " ")))
+    writer: getLineBufferedWriter(styleText7("dim", `[O-${pid}]`.padEnd(minPrefixLen, " ")))
   }, {
     source: subprocess.stderr,
     type: StdType.Err,
-    write: getLineBufferedWriter(styleText7("yellow", styleText7("dim", `[E-${pid}]`.padEnd(minPrefixLen, " "))))
-  }].map(({
+    writer: getLineBufferedWriter(styleText7("yellow", styleText7("dim", `[E-${pid}]`.padEnd(minPrefixLen, " "))), undefined, process.stderr.write.bind(process.stderr))
+  }].map(async ({
     source,
     type,
-    write
+    writer
   }) => {
-    return readStream(source, (chunk) => {
-      write(chunk);
+    await readStream(source, (chunk) => {
+      const processedChunk = type === StdType.Err ? stderrProcessor(chunk) : chunk;
+      if (processedChunk === "" && chunk !== "") {
+        return;
+      }
+      writer.write(processedChunk);
       if (opts.onStdChunk) {
-        opts.onStdChunk(chunk, type);
+        opts.onStdChunk(processedChunk, type);
       }
     });
+    writer.flush();
   });
   const executedCommand = commands.join(" ");
-  opts.logger.debug(styleText7("dim", `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 [
     ,
     ,
@@ -926,14 +997,14 @@ var runSubprocess = async (opts) => {
     readStderr,
     subprocess.exited.then((exitCode) => {
       if (cancelCodes.has(exitCode)) {
-        opts.logger.debug(styleText7("dim", `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(styleText7("red", `'${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(styleText7("dim", `Completed '${opts.debugName}' subprocess command; PID ${pid} exited.`));
+      opts.logger?.debug(styleText7("dim", `Completed '${opts.debugName}' subprocess command; PID ${pid} exited.`));
       return ExitState.Completed;
     })
   ]);
@@ -943,18 +1014,18 @@ var runSubprocess = async (opts) => {
 // 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);
+  let processPackageOrder = packageOrder.circular.length > 0 ? packageOrder.groups.concat([packageOrder.circular]) : packageOrder.groups;
   if (!topological) {
     processPackageOrder = [processPackageOrder.flat()];
   }
   for (const group of processPackageOrder) {
     await runAsync(group.map((packageName) => async () => {
-      const packageNode = assertDefined9(packageGraphs.dependencies.get(packageName));
+      const packageNode = assertDefined8(packageGraphs.dependencies.get(packageName));
       const processPackageProps = {
         name: packageName,
         dir: packageNode.packageData.dir
       };
-      const processPackageCwd = dirname6(packageNode.packageData.path);
+      const processPackageCwd = dirname4(packageNode.packageData.path);
       const shellCommand = await getCommand(processPackageProps);
       if (!shellCommand) {
         return;
@@ -963,6 +1034,10 @@ var runForEachPackage = async (packageGraphs, packageOrder, getCommand, logger,
         debugName: `run for ${packageName}`,
         shellCommand,
         cwd: processPackageCwd,
+        env: {
+          PP_PACKAGE_NAME: packageName,
+          PP_PACKAGE_DIR: processPackageProps.dir
+        },
         signal: controller.signal,
         logger
       });
@@ -974,139 +1049,24 @@ var runForEachPackage = async (packageGraphs, packageOrder, getCommand, logger,
   }
 };
 
-// packages/core/src/lib/package/functions/update-package-version.ts
-import { styleText as styleText8 } from "util";
-var {semver } = globalThis.Bun;
-import { inc } from "semver";
-var findAndReplaceVersion = ({
-  raw,
-  field,
-  packageName,
-  updatePackageName,
-  newVersion,
-  exact,
-  logger
-}) => {
-  if (field === "version" && packageName === updatePackageName) {
-    const versionKey = `"version"`;
-    const keyIndex = raw.indexOf(versionKey);
-    if (keyIndex === -1) {
-      return raw;
-    }
-    const versionStart2 = raw.indexOf('"', keyIndex + versionKey.length);
-    const versionEnd2 = raw.indexOf('"', versionStart2 + 1);
-    if (versionStart2 === -1 || versionEnd2 === -1) {
-      return raw;
-    }
-    const currentVersionString2 = raw.slice(versionStart2 + 1, versionEnd2);
-    const updatedVersion2 = newVersion;
-    logger.info(`Updating '${updatePackageName}' version: ${currentVersionString2} \u2192 ${updatedVersion2}.`);
-    const before2 = raw.slice(0, versionStart2 + 1);
-    const after2 = raw.slice(versionEnd2);
-    return `${before2}${updatedVersion2}${after2}`;
-  }
-  const fieldIndex = raw.indexOf(`"${field}"`);
-  if (fieldIndex === -1) {
-    return raw;
-  }
-  const fieldStart = raw.indexOf("{", fieldIndex);
-  if (fieldStart === -1) {
-    return raw;
-  }
-  const fieldEnd = raw.indexOf("}", fieldStart);
-  if (fieldEnd === -1) {
-    return raw;
-  }
-  const fieldBlock = raw.slice(fieldStart, fieldEnd);
-  const depKey = `"${packageName}"`;
-  const depIndex = fieldBlock.indexOf(depKey);
-  if (depIndex === -1) {
-    return raw;
-  }
-  const versionStart = fieldBlock.indexOf('"', depIndex + depKey.length);
-  const versionEnd = fieldBlock.indexOf('"', versionStart + 1);
-  if (versionStart === -1 || versionEnd === -1) {
-    return raw;
-  }
-  const currentVersionString = fieldBlock.slice(versionStart + 1, versionEnd);
-  const preservedPrefix = exact ? "" : /^([~^><=]*)/.exec(currentVersionString)?.[1] ?? "";
-  const updatedVersion = `${preservedPrefix}${newVersion}`;
-  logger.info(`Updating '${updatePackageName}' ${field} '${packageName}': ${currentVersionString} \u2192 ${updatedVersion}.`);
-  const before = raw.slice(0, fieldStart + versionStart + 1);
-  const after = raw.slice(fieldStart + versionEnd);
-  return `${before}${updatedVersion}${after}`;
-};
-var updatePackageVersion = async (packageName, type, packageGraphs, preId, exact, logger) => {
-  logger.debug(styleText8("dim", `Bumping package '${packageName}'...`));
-  const packageNode = packageGraphs.dependencies.get(packageName);
-  if (!packageNode) {
-    throw new Error(`Package '${packageName}' not found.`);
-  }
-  const currentVersion = packageNode.packageData.version;
-  if (!currentVersion) {
-    throw new Error(`Package '${packageName}' has no version.`);
-  }
-  const bumpedVersion = inc(currentVersion, type, undefined, preId);
-  if (!bumpedVersion) {
-    throw new Error(`Package '${packageName}' version '${currentVersion}' is invalid.`);
-  }
-  const updatedContent = findAndReplaceVersion({
-    raw: packageNode.packageData.rawContent,
-    field: "version",
-    packageName,
-    updatePackageName: packageName,
-    newVersion: bumpedVersion,
-    exact,
-    logger
-  });
-  const baseWrite = Bun.write(packageNode.packageData.path, updatedContent);
-  const dependentWrites = Array.from(dfsTraverseGraph(packageGraphs.dependents, packageName).flatMap((dependent) => {
-    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(styleText8("dim", `Skipping '${dependent.name}': ${field} version '${depVersion}' already satisfies '${bumpedVersion}'.`));
-        return [];
-      }
-      const updatedContent2 = findAndReplaceVersion({
-        raw: dependent.rawContent,
-        field,
-        packageName,
-        updatePackageName: dependent.name,
-        newVersion: bumpedVersion,
-        exact,
-        logger
-      });
-      return [Bun.write(dependent.path, updatedContent2)];
-    });
-  }));
-  return Promise.all([baseWrite, ...dependentWrites]).then(() => {
-    return;
-  });
-};
-
 // packages/core/src/lib/watch/functions/watch-package-changes.ts
 import {
   watch
 } from "fs";
-import { styleText as styleText10 } from "util";
 import {
-  dirname as dirname8,
-  join as join4
+  dirname as dirname6,
+  join as join3
 } from "path";
+import { styleText as styleText9 } from "util";
 import {
   assertDefined as assertDefined12,
-  DedupePathsBy,
-  dedupeSharedPaths,
   getDeferredPromise,
   getStringMatcher,
   isDefined as isDefined4,
-  runAsync as runAsync2
+  normalisePath,
+  runAsync as runAsync3
 } from "@package-pal/util";
-var {Glob: Glob2 } = globalThis.Bun;
+var {Glob } = globalThis.Bun;
 
 // packages/core/src/lib/graph/functions/merge-graphs.ts
 var mergeGraphs = (a, b) => {
@@ -1133,18 +1093,72 @@ var ChangeAction = {
   Restart: "Restart"
 };
 
+// packages/core/src/lib/watch/types/dedupe-paths-by.ts
+var DedupePathsBy = {
+  Parent: "parent",
+  Child: "child"
+};
+
+// packages/core/src/lib/watch/functions/dedupe-shared-paths.ts
+import { sep } from "path";
+import { assertDefined as assertDefined9 } from "@package-pal/util";
+var dedupeSharedPaths = (paths, by) => {
+  const mapped = paths.map((path) => {
+    let count = 0;
+    for (const char of path) {
+      if (char === sep) {
+        count++;
+      }
+    }
+    return {
+      path,
+      count
+    };
+  });
+  mapped.sort((a, b) => a.count - b.count);
+  const sorted = mapped.map((item) => item.path);
+  const deduped = [];
+  if (by === DedupePathsBy.Parent) {
+    for (const path of sorted) {
+      if (!deduped.some((base) => path.startsWith(base + sep))) {
+        deduped.push(path);
+      }
+    }
+    return deduped;
+  }
+  for (const path of sorted) {
+    for (let i = deduped.length - 1;i >= 0; i--) {
+      const base = assertDefined9(deduped[i]);
+      if (path.startsWith(base + sep)) {
+        deduped.splice(i, 1);
+      }
+    }
+    if (!deduped.some((base) => base.startsWith(path + sep))) {
+      deduped.push(path);
+    }
+  }
+  return Array.from(new Set(deduped));
+};
+
 // packages/core/src/lib/watch/functions/filter-files-modified-since.ts
-var filterFilesModifiedSince = (paths, sinceMs) => {
-  return paths.filter((path) => {
-    const changedFile = Bun.file(path);
-    const isDeleted = changedFile.lastModified === 0;
-    const isModifiedSince = changedFile.lastModified >= sinceMs;
-    return isDeleted || isModifiedSince;
+import { stat } from "fs/promises";
+import { runAsync as runAsync2 } from "@package-pal/util";
+var filterFilesModifiedSince = async (paths, sinceMs) => {
+  const tasks = paths.map((path) => async () => {
+    try {
+      const s = await stat(path);
+      const isModifiedSince = s.mtimeMs >= sinceMs;
+      return isModifiedSince ? path : null;
+    } catch {
+      return path;
+    }
   });
+  const results = await runAsync2(tasks, 20);
+  return results.filter((path) => path !== null);
 };
 
 // packages/core/src/lib/watch/functions/get-change-logic.ts
-import { styleText as styleText9 } from "util";
+import { styleText as styleText8 } from "util";
 import { assertDefined as assertDefined11 } from "@package-pal/util";
 
 // packages/core/src/lib/graph/functions/generate-topological-ranking-range.ts
@@ -1245,21 +1259,21 @@ var getChangeLogic = (packageGraphs, packageChanges, lastProcessedSubgraph, conf
   const changedPackages = Array.from(packageChanges.keys());
   const changedFilePaths = Array.from(packageChanges.values()).flat();
   if (packageChanges.size) {
-    logger.debug(styleText9("dim", `Changes detected in ${changedPackages.map((packageName) => `'${packageName}'`).join(", ")}.`));
-    logger.debug(styleText9("dim", `Changed file paths: ${changedFilePaths.map((filePath) => `'${filePath}'`).join(", ")}.`));
+    logger?.debug(styleText8("dim", `Changes detected in ${changedPackages.map((packageName) => `'${packageName}'`).join(", ")}.`));
+    logger?.debug(styleText8("dim", `Changed file paths: ${changedFilePaths.map((filePath) => `'${filePath}'`).join(", ")}.`));
   }
   const packageOrder = generateTopologicalSortedGroups(packageGraphs.dependents, logger);
-  const packageProcessOrder = packageOrder.groups.toReversed().concat(packageOrder.circular);
+  const packageProcessOrder = packageOrder.circular.length > 0 ? packageOrder.groups.toReversed().concat([packageOrder.circular]) : packageOrder.groups.toReversed();
   const packageRankings = generateTopologicalRanking(packageProcessOrder);
   const changedPackageSubgraph = extractSubgraph(packageGraphs.dependents, changedPackages);
   const changedPackageOrder = generateTopologicalSortedGroups(changedPackageSubgraph, logger);
-  const changedPackageProcessOrder = changedPackageOrder.groups.toReversed().concat(changedPackageOrder.circular);
+  const changedPackageProcessOrder = changedPackageOrder.circular.length > 0 ? changedPackageOrder.groups.toReversed().concat([changedPackageOrder.circular]) : changedPackageOrder.groups.toReversed();
   const isSubgraphOfPrevious = !!lastProcessedSubgraph && isSubgraph(lastProcessedSubgraph, changedPackageSubgraph);
   const isDisjointFromPrevious = !lastProcessedSubgraph || !isSubgraphOfPrevious && isDisjoint(lastProcessedSubgraph, changedPackageSubgraph);
   const isRankedGreaterThanOrEqualToPrevious = !!lastProcessedSubgraph && !isSubgraphOfPrevious && isRankedGreaterThanOrEqual(lastProcessedSubgraph, changedPackageSubgraph, packageRankings);
-  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()}.`));
+  logger?.debug(styleText8("dim", `Changes are subgraph of previous: ${isSubgraphOfPrevious.toString()}.`));
+  logger?.debug(styleText8("dim", `Changes are disjoint from previous: ${isDisjointFromPrevious.toString()}.`));
+  logger?.debug(styleText8("dim", `Changes are ranked greater than or equal to previous: ${isRankedGreaterThanOrEqualToPrevious.toString()}.`));
   let action = ChangeAction.Restart;
   if (!packageChanges.size) {
     action = ChangeAction.Ignore;
@@ -1279,7 +1293,7 @@ var getChangeLogic = (packageGraphs, packageChanges, lastProcessedSubgraph, conf
       });
     }
   }
-  logger.debug(styleText9("dim", `Determined change action: ${action}.`));
+  logger?.debug(styleText8("dim", `Determined change action: ${action}.`));
   return {
     changedPackageProcessOrder,
     changedPackageSubgraph,
@@ -1287,16 +1301,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,
-  dirname as dirname7,
-  join as join3
+  dirname as dirname5,
+  join as join2
 } from "path";
 var removeTrailing = [
   "~",
@@ -1309,34 +1318,34 @@ var removeTrailing = [
   ".swn"
 ];
 var normaliseWatchedFilePath = (filePath) => {
-  const dir = dirname7(filePath);
+  const dir = dirname5(filePath);
   let base = basename3(filePath);
+  const baseLower = base.toLowerCase();
   for (const trailing of removeTrailing) {
-    if (base.toLowerCase().endsWith(trailing)) {
+    if (baseLower.endsWith(trailing)) {
       const sliceStart = base.startsWith(".") ? 1 : 0;
       base = base.slice(sliceStart, -trailing.length);
       break;
     }
   }
-  return join3(dir, base);
+  return join2(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) => {
+var onProcessPackage = async (packageGraphs, packageChanges, watchConfig, determineAbortController, state, logger) => {
   const {
     action,
     changedPackageProcessOrder,
     changedPackageSubgraph
-  } = getChangeLogic(packageGraphs, packageChanges, lastProcessedSubgraph, watchConfig, logger);
+  } = getChangeLogic(packageGraphs, packageChanges, state.lastProcessedSubgraph, watchConfig, logger);
   const isRestart = action === ChangeAction.Restart;
   const isSequential = watchConfig.subprocess.concurrency === 1;
   const controller = determineAbortController(isRestart);
   const onProcessFailure = () => {
-    logger.debug(styleText10("dim", "Aborting controller: process failed."));
+    logger.debug(styleText9("dim", "Aborting controller: process failed."));
     controller.abort();
-    lastProcessedSubgraph = undefined;
+    state.lastProcessedSubgraph = undefined;
   };
   if (action === ChangeAction.Ignore && packageChanges.size) {
     logger.info(`Changes detected; but were ignored due to 'partialProcessing: true'. Waiting for changes..`);
@@ -1344,10 +1353,10 @@ var onProcessPackage = async (packageGraphs, packageChanges, watchConfig, determ
   }
   if (packageChanges.size) {
     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;
+    state.lastProcessedSubgraph = state.lastProcessedSubgraph && !isRestart ? mergeGraphs(state.lastProcessedSubgraph, changedPackageSubgraph) : changedPackageSubgraph;
   }
   for (const group of changedPackageProcessOrder) {
-    await runAsync2(group.map((packageName) => async () => {
+    await runAsync3(group.map((packageName) => async () => {
       const packageNode = assertDefined12(packageGraphs.dependencies.get(packageName));
       const changedPaths = packageChanges.get(packageName) ?? [];
       const processPackageProps = {
@@ -1358,7 +1367,7 @@ var onProcessPackage = async (packageGraphs, packageChanges, watchConfig, determ
         totalProcessOrder: changedPackageProcessOrder,
         signal: controller.signal
       };
-      const processPackageCwd = dirname8(packageNode.packageData.path);
+      const processPackageCwd = dirname6(packageNode.packageData.path);
       const beforeProcessPackageShellCommand = await watchConfig.hooks.onBeforeProcessPackage(processPackageProps);
       if (beforeProcessPackageShellCommand) {
         await runSubprocess({
@@ -1399,7 +1408,7 @@ var onProcessPackage = async (packageGraphs, packageChanges, watchConfig, determ
             if (!errored) {
               const matchedErrorText = erroredMatcher?.push(chunk).matched();
               if (matchedErrorText) {
-                logger.error(styleText10("red", `'${packageName}' subprocess matched error text '${matchedErrorText}'.`));
+                logger.error(styleText9("red", `'${packageName}' subprocess matched error text '${matchedErrorText}'.`));
                 errored = true;
                 Promise.resolve(watchConfig.hooks.onProcessPackageError(processPackageProps)).then((processPackageErrorCommand) => {
                   if (!processPackageErrorCommand) {
@@ -1477,17 +1486,18 @@ var onProcessPackage = async (packageGraphs, packageChanges, watchConfig, determ
 };
 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.`));
+  logger.debug(styleText9("dim", `Starting ${dedupedRootPackageData.length.toString()} watchers for ${packageData.length.toString()} packages.`));
   let closed = false;
+  const state = { lastProcessedSubgraph: undefined };
   let debounceTimeout;
   let startedDebounceMs;
   let controller;
-  const ignoreGlobs = watchConfig.ignore ? (Array.isArray(watchConfig.ignore) ? watchConfig.ignore : [watchConfig.ignore]).map((pattern) => new Glob2(pattern)) : undefined;
+  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(styleText10("dim", "Aborting controller: reset for new packages."));
+        logger.debug(styleText9("dim", "Aborting controller: reset for new packages."));
         controller.abort();
       }
       controller = undefined;
@@ -1505,12 +1515,12 @@ var watchPackageChanges = (packageData, packageGraphs, watchConfig, rootDir, log
       startedDebounceMs = Date.now();
     }
     if (packageName && watchPath && filePath) {
-      const changedPath = normalisePatternSeparators(join4(watchPath, normaliseWatchedFilePath(filePath)));
+      const changedPath = normalisePath(join3(watchPath, normaliseWatchedFilePath(filePath)));
       if (ignoreGlobs?.some((glob) => glob.match(changedPath))) {
-        logger.debug(styleText10("dim", `Ignoring change '${changedPath}' (matched ignore pattern).`));
+        logger.debug(styleText9("dim", `Ignoring change '${changedPath}' (matched ignore pattern).`));
         return;
       }
-      logger.debug(styleText10("dim", `Tracked change '${changedPath}'.`));
+      logger.debug(styleText9("dim", `Tracked change '${changedPath}'.`));
       const existingPaths = changedPackagePaths.get(packageName);
       if (existingPaths) {
         existingPaths.add(changedPath);
@@ -1523,30 +1533,32 @@ var watchPackageChanges = (packageData, packageGraphs, watchConfig, rootDir, log
     }
     const debounceMs = isInitial ? 0 : watchConfig.debounceMs;
     debounceTimeout = setTimeout(() => {
-      if (closed) {
-        return;
-      }
-      const packageChanges = new Map;
-      for (const [packageName2, paths] of changedPackagePaths) {
-        const dedupedPaths = dedupeSharedPaths(Array.from(paths), DedupePathsBy.Child).sort();
-        const processedPaths = filterFilesModifiedSince(dedupedPaths, assertDefined12(startedDebounceMs) - fileModifiedThresholdMs);
-        if (processedPaths.length) {
-          packageChanges.set(packageName2, processedPaths);
+      (async () => {
+        if (closed) {
+          return;
         }
-      }
-      startedDebounceMs = undefined;
-      changedPackagePaths.clear();
-      if (!packageChanges.size && !isInitial) {
-        return;
-      }
-      onProcessPackage(packageGraphs, packageChanges, watchConfig, (reset) => useController(reset), logger);
+        const packageChanges = new Map;
+        for (const [packageName2, paths] of changedPackagePaths) {
+          const dedupedPaths = dedupeSharedPaths(Array.from(paths), DedupePathsBy.Child).sort();
+          const processedPaths = await filterFilesModifiedSince(dedupedPaths, assertDefined12(startedDebounceMs) - fileModifiedThresholdMs);
+          if (processedPaths.length) {
+            packageChanges.set(packageName2, processedPaths);
+          }
+        }
+        startedDebounceMs = undefined;
+        changedPackagePaths.clear();
+        if (!packageChanges.size && !isInitial) {
+          return;
+        }
+        onProcessPackage(packageGraphs, packageChanges, watchConfig, (reset) => useController(reset), state, logger);
+      })();
     }, debounceMs);
   };
   const watchers = dedupedRootPackageData.map(({
     name,
     path
   }) => {
-    const watchPath = dirname8(path);
+    const watchPath = dirname6(path);
     return watch(watchPath, { recursive: true }, (event, filePath) => {
       onWatchEvent({
         watchPath,
@@ -1560,12 +1572,12 @@ var watchPackageChanges = (packageData, packageGraphs, watchConfig, rootDir, log
     watchers.forEach((watcher) => {
       watcher.close();
     });
-    logger.debug(styleText10("dim", "Aborting controller: closing watchers."));
+    logger.debug(styleText9("dim", "Aborting controller: closing watchers."));
     controller?.abort();
     closed = true;
   };
   process.on("SIGINT", () => {
-    logger.debug(styleText10("dim", "Received SIGINT: closing watchers."));
+    logger.debug(styleText9("dim", "Received SIGINT: closing watchers."));
     closeWatchers();
     process.exit(0);
   });
@@ -1583,10 +1595,10 @@ var watchPackageChanges = (packageData, packageGraphs, watchConfig, rootDir, log
   });
   return { close: () => {
     if (closed) {
-      logger.debug(styleText10("dim", "Watchers already closed."));
+      logger.debug(styleText9("dim", "Watchers already closed."));
       return;
     }
-    logger.debug(styleText10("dim", "Closing watchers."));
+    logger.debug(styleText9("dim", "Closing watchers."));
     closeWatchers();
   } };
 };
@@ -1599,7 +1611,7 @@ var readPackagePalConfig = (options) => {
 var readPackageData = async (options) => {
   checkBun();
   const packagePatterns = Array.isArray(options.config.packages) ? options.config.packages : [options.config.packages];
-  return loadPackages(options.rootDir, packagePatterns, options.config.logger);
+  return loadPackages(options.rootDir, packagePatterns, options.adapter, options.config.logger);
 };
 var getPackageGraphs = (options) => {
   checkBun();
@@ -1613,11 +1625,9 @@ var getPackageCircularDependencyPaths = (options) => {
   checkBun();
   return generatePackageCircularDependencyPaths(options.packageGraphs, options.packageOrder, options.config.logger);
 };
-var bumpPackageVersion = (options) => {
+var bumpPackageVersion2 = (options) => {
   checkBun();
-  const exact = isDefined5(options.exact) ? options.exact : options.config.version.exact;
-  const preId = isDefined5(options.preId) ? options.preId : options.config.version.preId;
-  return updatePackageVersion(options.packageName, options.type, options.packageGraphs, preId, exact, options.config.logger);
+  return bumpPackageVersion(options);
 };
 var watchPackages = (options) => {
   checkBun();
@@ -1629,15 +1639,18 @@ var forEachPackage = (options) => {
 };
 export {
   watchPackages,
+  scanPackagePaths,
   readPackagePalConfig,
   readPackageData,
   getPackageOrder,
   getPackageGraphs,
   getPackageCircularDependencyPaths,
   forEachPackage,
-  bumpPackageVersion,
+  dfsTraverseGraph2 as dfsTraverseGraph,
+  bumpPackageVersion2 as bumpPackageVersion,
+  PackageAdapter,
   BumpVersionType
 };
 
-//# debugId=C0E622D78585C05964756E2164756E21
+//# debugId=C18A12C7802A030C64756E2164756E21
 //# sourceMappingURL=index.js.map