@package-pal/core 0.0.8 → 0.0.11

package/index.js

@@ -9,8 +9,11 @@ var BumpVersionType = {
   Prepatch: "prepatch",
   Prerelease: "prerelease"
 };
+// packages/core/src/lib/package/types/package-adapter.ts
+class PackageAdapter {
+}
 // packages/core/src/lib/api.ts
-import { isDefined as isDefined5 } from "@package-pal/util";
+import { isDefined as isDefined4 } from "@package-pal/util";
 
 // packages/core/src/lib/configuration/functions/check-bun.ts
 var checkBun = () => {
@@ -20,9 +23,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 +88,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 +218,7 @@ var searchConfigPath = async (pathOverride) => {
 
 // packages/core/src/lib/configuration/functions/load-config.ts
 var defaultConfig = {
+  adapter: "auto",
   packages: "packages/*",
   version: {
     preId: "",
@@ -241,7 +250,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,32 +277,16 @@ ${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) => {
@@ -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) {
@@ -361,7 +355,7 @@ var dfsTraverseGraphPaths = function* (graph, traverseFromPackages) {
         }
         continue;
       }
-      if (globalVisited.has(node)) {
+      if (useGlobalVisited && globalVisited.has(node)) {
         continue;
       }
       const newPath = [...path, node];
@@ -382,7 +376,9 @@ var dfsTraverseGraphPaths = function* (graph, traverseFromPackages) {
       if (!pushed) {
         yield newPath;
       }
-      globalVisited.add(node);
+      if (useGlobalVisited) {
+        globalVisited.add(node);
+      }
     }
   }
 };
@@ -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,11 +511,14 @@ 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..."));
+  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]));
@@ -549,10 +553,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()),
@@ -561,98 +565,13 @@ 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
 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;
-  const {
-    dependencies,
-    peerDependencies,
-    devDependencies
-  } = props;
-  for (const field of Object.values(DependenciesField)) {
-    const value = props[field];
-    if (isDefined2(value) && typeof value !== "object") {
-      return;
-    }
-  }
-  return {
-    rawContent: text,
-    path,
-    name: props.name ?? path,
-    dir: basename2(dirname4(path)),
-    version: props.version ?? undefined,
-    dependencies: dependencies ?? undefined,
-    peerDependencies: peerDependencies ?? undefined,
-    devDependencies: devDependencies ?? undefined
-  };
-};
-
-// packages/core/src/lib/package/functions/scan-package-paths.ts
-import { scanGlobPatternPaths } from "@package-pal/util";
-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;
-      }
-      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))}.`));
-    }
-  }
-};
-
-// packages/core/src/lib/package/functions/load-packages.ts
-var loadPackages = async (rootDir, packagePatterns, logger) => {
+var loadPackages = async (rootDir, packagePatterns, adapter, logger) => {
   const patternContent = packagePatterns.map((pattern) => `'${pattern}'`).join(", ");
-  logger.debug(styleText6("dim", `Loading packages matching pattern/s ${patternContent}...${rootDir ? ` from ${rootDir}` : ""}`));
+  logger.debug(styleText5("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(packagePatterns)), logger, rootDir)) {
     if (seen.has(packageData.name)) {
       continue;
     }
@@ -666,14 +585,14 @@ 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";
 
 // packages/core/src/lib/process/functions/run-subprocess.ts
-import { styleText as styleText7 } from "util";
+import { styleText as styleText6 } from "util";
 
 // packages/core/src/lib/process/types/exit-state.ts
 var ExitState = {
@@ -689,18 +608,94 @@ var StdType = {
 };
 
 // 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 {
-  escapeShellArg,
-  getShell,
-  Shell
-} from "@package-pal/util";
+  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",
@@ -714,45 +709,83 @@ 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/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;
+    }
+    const hasClixmlHeader = buffer.includes("#< CLIXML");
+    const hasClixmlTags = /<Obj|S S="Error"|<\/Objs>/.test(buffer);
+    if (!hasClixmlHeader && !hasClixmlTags) {
+      const out = buffer;
+      buffer = "";
+      return out;
+    }
+    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
 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 {
@@ -761,35 +794,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 = lines.pop() ?? "";
-    for (const line of lines) {
-      write(`${prefix}${style(line)}
+          buffer = "";
+        }
+        return;
+      }
+      buffer += chunk;
+      let start = 0;
+      let newlineIndex = buffer.indexOf(`
 `);
+      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);
     }
   };
 };
@@ -798,10 +862,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) {
@@ -820,14 +888,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(styleText6("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,
@@ -840,25 +915,30 @@ var runSubprocess = async (opts) => {
   const [readStdout, readStderr] = [{
     source: subprocess.stdout,
     type: StdType.Out,
-    write: getLineBufferedWriter(styleText7("dim", `[O-${pid}]`.padEnd(minPrefixLen, " ")))
+    writer: getLineBufferedWriter(styleText6("dim", `[O-${pid}]`.padEnd(minPrefixLen, " ")))
   }, {
     source: subprocess.stderr,
     type: StdType.Err,
-    write: getLineBufferedWriter(styleText7("yellow", styleText7("dim", `[E-${pid}]`.padEnd(minPrefixLen, " "))))
-  }].map(({
+    writer: getLineBufferedWriter(styleText6("yellow", styleText6("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(styleText6("dim", `Started '${opts.debugName}' subprocess command '${opts.shellCommand}' (${executedCommand}) with PID ${pid}.`));
   const [
     ,
     ,
@@ -868,14 +948,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(styleText6("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(styleText6("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(styleText6("dim", `Completed '${opts.debugName}' subprocess command; PID ${pid} exited.`));
       return ExitState.Completed;
     })
   ]);
@@ -885,18 +965,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;
@@ -905,6 +985,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
       });
@@ -916,136 +1000,21 @@ 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 styleText8 } from "util";
 import {
   assertDefined as assertDefined12,
-  DedupePathsBy,
-  dedupeSharedPaths,
   getDeferredPromise,
   getStringMatcher,
-  isDefined as isDefined4,
+  isDefined as isDefined3,
+  normalisePath,
   runAsync as runAsync2
 } from "@package-pal/util";
 var {Glob } = globalThis.Bun;
@@ -1075,28 +1044,67 @@ 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 sorted = paths.toSorted((a, b) => a.split(sep).length - b.split(sep).length);
+  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";
+var filterFilesModifiedSince = async (paths, sinceMs) => {
+  const results = await Promise.all(paths.map(async (path) => {
+    try {
+      const s = await stat(path);
+      const isModifiedSince = s.mtimeMs >= sinceMs;
+      return isModifiedSince ? path : null;
+    } catch {
+      return path;
+    }
+  }));
+  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 styleText7 } from "util";
 import { assertDefined as assertDefined11 } from "@package-pal/util";
 
 // packages/core/src/lib/graph/functions/generate-topological-ranking-range.ts
-import { isDefined as isDefined3 } from "@package-pal/util";
+import { isDefined as isDefined2 } from "@package-pal/util";
 var generateTopologicalRankingRange = (graph, ranking) => {
   let min = Infinity;
   let max = -Infinity;
   for (const key of graph.keys()) {
     const rank = ranking.get(key);
-    if (!isDefined3(rank)) {
+    if (!isDefined2(rank)) {
       continue;
     }
     if (rank < min) {
@@ -1187,21 +1195,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(styleText7("dim", `Changes detected in ${changedPackages.map((packageName) => `'${packageName}'`).join(", ")}.`));
+    logger?.debug(styleText7("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(styleText7("dim", `Changes are subgraph of previous: ${isSubgraphOfPrevious.toString()}.`));
+  logger?.debug(styleText7("dim", `Changes are disjoint from previous: ${isDisjointFromPrevious.toString()}.`));
+  logger?.debug(styleText7("dim", `Changes are ranked greater than or equal to previous: ${isRankedGreaterThanOrEqualToPrevious.toString()}.`));
   let action = ChangeAction.Restart;
   if (!packageChanges.size) {
     action = ChangeAction.Ignore;
@@ -1221,7 +1229,7 @@ var getChangeLogic = (packageGraphs, packageChanges, lastProcessedSubgraph, conf
       });
     }
   }
-  logger.debug(styleText9("dim", `Determined change action: ${action}.`));
+  logger?.debug(styleText7("dim", `Determined change action: ${action}.`));
   return {
     changedPackageProcessOrder,
     changedPackageSubgraph,
@@ -1229,16 +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,
-  dirname as dirname7,
-  join as join3
+  dirname as dirname5,
+  join as join2
 } from "path";
 var removeTrailing = [
   "~",
@@ -1251,7 +1254,7 @@ var removeTrailing = [
   ".swn"
 ];
 var normaliseWatchedFilePath = (filePath) => {
-  const dir = dirname7(filePath);
+  const dir = dirname5(filePath);
   let base = basename3(filePath);
   for (const trailing of removeTrailing) {
     if (base.toLowerCase().endsWith(trailing)) {
@@ -1260,33 +1263,32 @@ var normaliseWatchedFilePath = (filePath) => {
       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(styleText8("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..`);
     return;
   }
   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;
+    logger.info(`${isRestart ? "Restarting processing" : "Initiating partial processing"} ${isSequential ? "sequentially" : `in parallel${isDefined3(watchConfig.subprocess.concurrency) ? ` with concurrency ${watchConfig.subprocess.concurrency.toString()}` : ""}`}.`);
+    state.lastProcessedSubgraph = state.lastProcessedSubgraph && !isRestart ? mergeGraphs(state.lastProcessedSubgraph, changedPackageSubgraph) : changedPackageSubgraph;
   }
   for (const group of changedPackageProcessOrder) {
     await runAsync2(group.map((packageName) => async () => {
@@ -1300,7 +1302,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({
@@ -1341,7 +1343,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(styleText8("red", `'${packageName}' subprocess matched error text '${matchedErrorText}'.`));
                 errored = true;
                 Promise.resolve(watchConfig.hooks.onProcessPackageError(processPackageProps)).then((processPackageErrorCommand) => {
                   if (!processPackageErrorCommand) {
@@ -1419,8 +1421,9 @@ 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(styleText8("dim", `Starting ${dedupedRootPackageData.length.toString()} watchers for ${packageData.length.toString()} packages.`));
   let closed = false;
+  const state = { lastProcessedSubgraph: undefined };
   let debounceTimeout;
   let startedDebounceMs;
   let controller;
@@ -1429,7 +1432,7 @@ var watchPackageChanges = (packageData, packageGraphs, watchConfig, rootDir, log
   const useController = (reset) => {
     if (controller && (reset || controller.signal.aborted)) {
       if (reset) {
-        logger.debug(styleText10("dim", "Aborting controller: reset for new packages."));
+        logger.debug(styleText8("dim", "Aborting controller: reset for new packages."));
         controller.abort();
       }
       controller = undefined;
@@ -1443,16 +1446,16 @@ var watchPackageChanges = (packageData, packageGraphs, watchConfig, rootDir, log
     filePath,
     isInitial = false
   }) => {
-    if (!isDefined4(startedDebounceMs)) {
+    if (!isDefined3(startedDebounceMs)) {
       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(styleText8("dim", `Ignoring change '${changedPath}' (matched ignore pattern).`));
         return;
       }
-      logger.debug(styleText10("dim", `Tracked change '${changedPath}'.`));
+      logger.debug(styleText8("dim", `Tracked change '${changedPath}'.`));
       const existingPaths = changedPackagePaths.get(packageName);
       if (existingPaths) {
         existingPaths.add(changedPath);
@@ -1465,30 +1468,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,
@@ -1502,12 +1507,12 @@ var watchPackageChanges = (packageData, packageGraphs, watchConfig, rootDir, log
     watchers.forEach((watcher) => {
       watcher.close();
     });
-    logger.debug(styleText10("dim", "Aborting controller: closing watchers."));
+    logger.debug(styleText8("dim", "Aborting controller: closing watchers."));
     controller?.abort();
     closed = true;
   };
   process.on("SIGINT", () => {
-    logger.debug(styleText10("dim", "Received SIGINT: closing watchers."));
+    logger.debug(styleText8("dim", "Received SIGINT: closing watchers."));
     closeWatchers();
     process.exit(0);
   });
@@ -1525,10 +1530,10 @@ var watchPackageChanges = (packageData, packageGraphs, watchConfig, rootDir, log
   });
   return { close: () => {
     if (closed) {
-      logger.debug(styleText10("dim", "Watchers already closed."));
+      logger.debug(styleText8("dim", "Watchers already closed."));
       return;
     }
-    logger.debug(styleText10("dim", "Closing watchers."));
+    logger.debug(styleText8("dim", "Closing watchers."));
     closeWatchers();
   } };
 };
@@ -1541,7 +1546,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();
@@ -1557,9 +1562,16 @@ var getPackageCircularDependencyPaths = (options) => {
 };
 var bumpPackageVersion = (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);
+  const exact = isDefined4(options.exact) ? options.exact : options.config.version.exact;
+  const preId = isDefined4(options.preId) ? options.preId : options.config.version.preId;
+  return options.adapter.updateVersion({
+    packageName: options.packageName,
+    type: options.type,
+    packageGraphs: options.packageGraphs,
+    preId,
+    exact,
+    logger: options.config.logger
+  });
 };
 var watchPackages = (options) => {
   checkBun();
@@ -1571,15 +1583,18 @@ var forEachPackage = (options) => {
 };
 export {
   watchPackages,
+  scanPackagePaths,
   readPackagePalConfig,
   readPackageData,
   getPackageOrder,
   getPackageGraphs,
   getPackageCircularDependencyPaths,
   forEachPackage,
+  dfsTraverseGraph2 as dfsTraverseGraph,
   bumpPackageVersion,
+  PackageAdapter,
   BumpVersionType
 };
 
-//# debugId=68AF287603F1263364756E2164756E21
+//# debugId=2C554E09012C798F64756E2164756E21
 //# sourceMappingURL=index.js.map