@package-pal/core 0.0.1

package/dist/index.js

@@ -0,0 +1,1431 @@
+// @bun
+// src/lib/types/bump-version-type.ts
+var BumpVersionType = {
+  Major: "major",
+  Minor: "minor",
+  Patch: "patch",
+  Premajor: "premajor",
+  Preminor: "preminor",
+  Prepatch: "prepatch",
+  Prerelease: "prerelease"
+};
+// src/lib/api.ts
+import { isDefined as isDefined5 } from "@package-pal/util";
+
+// src/lib/configuration/functions/check-bun.ts
+var checkBun = () => {
+  if (!Bun) {
+    throw new Error("This package must be run with the Bun runtime.");
+  }
+};
+
+// src/lib/configuration/functions/load-config.ts
+import {
+  deepMergeDefined,
+  formatSimpleLogObject,
+  noOp as noOp2
+} from "@package-pal/util";
+import {
+  bgGray,
+  dim
+} from "yoctocolors";
+
+// src/lib/configuration/functions/get-default-logger.ts
+import {
+  assertDefined,
+  noOp
+} from "@package-pal/util";
+var levelOrder = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+  silent: Infinity
+};
+var getDefaultLogger = (logLevel) => {
+  const level = assertDefined(levelOrder[logLevel]);
+  return {
+    debug: level <= levelOrder.debug ? console.debug : noOp,
+    info: level <= levelOrder.info ? console.info : noOp,
+    warn: level <= levelOrder.warn ? console.warn : noOp,
+    error: level <= levelOrder.error ? console.error : noOp
+  };
+};
+
+// src/lib/configuration/schemas/config.ts
+import * as z3 from "zod/mini";
+
+// src/lib/configuration/functions/z-loose-function.ts
+import { z } from "zod/mini";
+var zLooseFunction = () => {
+  return z.transform((arg, ctx) => {
+    if (typeof arg !== "function") {
+      ctx.issues.push({
+        message: "Expected a function",
+        code: "custom",
+        input: arg
+      });
+      return z.NEVER;
+    }
+    return arg;
+  });
+};
+
+// src/lib/configuration/functions/z-loose-object-without-index-signature.ts
+import * as z2 from "zod/mini";
+var zLooseObjectWithoutIndexSignature = (shape, params) => {
+  return z2.looseObject(shape, params);
+};
+
+// src/lib/configuration/schemas/config.ts
+var LogLevel = z3.enum([
+  "debug",
+  "info",
+  "warn",
+  "error",
+  "silent"
+]);
+var Config = z3.object({
+  packages: z3.optional(z3.union([z3.string(), z3.array(z3.string())])),
+  version: z3.optional(z3.object({
+    preId: z3.optional(z3.string()),
+    exact: z3.optional(z3.boolean())
+  })),
+  watch: z3.optional(zLooseObjectWithoutIndexSignature({
+    debounceMs: z3.optional(z3.number()),
+    hooks: z3.optional(z3.object({
+      onBeforeProcessPackage: z3.optional(zLooseFunction()),
+      onProcessPackage: z3.optional(zLooseFunction()),
+      onProcessPackageError: z3.optional(zLooseFunction()),
+      onAfterProcessPackage: z3.optional(zLooseFunction()),
+      onBeforePackagesReady: z3.optional(zLooseFunction()),
+      onPackagesReady: z3.optional(zLooseFunction()),
+      onAfterPackagesReady: z3.optional(zLooseFunction())
+    })),
+    subprocess: z3.optional(z3.object({
+      partialProcessing: z3.optional(z3.boolean()),
+      parallelProcessing: z3.optional(z3.boolean()),
+      matchLongRunningOutputAsReady: z3.nullish(z3.string()),
+      matchLongRunningOutputAsErrored: z3.nullish(z3.string())
+    }))
+  })),
+  logLevel: z3.optional(LogLevel)
+});
+
+// src/lib/configuration/functions/validate-config-path.ts
+import {
+  basename,
+  extname
+} from "path";
+
+// src/lib/configuration/types/supported-config-type.ts
+var SupportedConfigType = {
+  TS: "ts",
+  CTS: "cts",
+  MTS: "mts",
+  JS: "js",
+  CJS: "cjs",
+  MJS: "mjs"
+};
+
+// src/lib/configuration/functions/validate-config-path.ts
+var CONFIG_SUPPORTED_BASE_NAME = "ppal.config";
+var CONFIG_SUPPORTED_TYPES = Object.values(SupportedConfigType);
+var CONFIG_SUPPORTED_NAMES = CONFIG_SUPPORTED_TYPES.map((type) => `${CONFIG_SUPPORTED_BASE_NAME}.${type}`);
+var validateConfigPath = (path) => {
+  const name = basename(path);
+  const extension = extname(path);
+  const type = CONFIG_SUPPORTED_TYPES.find((option) => `.${option}` === extension);
+  if (!name.startsWith(CONFIG_SUPPORTED_BASE_NAME) || !type) {
+    return {
+      valid: false,
+      errorMessage: `'${name}' is not a valid config file. Only '${CONFIG_SUPPORTED_NAMES.join(", ")}' are supported.`
+    };
+  }
+  return {
+    valid: true,
+    name,
+    type
+  };
+};
+
+// src/lib/configuration/functions/parse-config.ts
+var parseConfig = async (path) => {
+  const result = validateConfigPath(path);
+  if (!result.valid) {
+    throw new Error(result.errorMessage);
+  }
+  const module = await import(path);
+  const base = module.default ?? module;
+  return Config.parse(base);
+};
+
+// src/lib/configuration/functions/search-config-path.ts
+import {
+  isAbsolute,
+  join,
+  dirname as dirname2
+} from "path";
+import { isDefined } from "@package-pal/util";
+
+// src/lib/configuration/functions/is-root-dir.ts
+import { dirname } from "path";
+var isRootDir = (path) => {
+  return dirname(path) === path;
+};
+
+// src/lib/configuration/functions/search-config-path.ts
+var dirDistLimit = 25;
+var checkForConfigInDir = async (dir) => {
+  return new Promise((resolve) => {
+    let pending = CONFIG_SUPPORTED_NAMES.length;
+    for (const name of CONFIG_SUPPORTED_NAMES) {
+      const pathToCheck = join(dir, name);
+      Bun.file(pathToCheck).exists().then((exists) => {
+        pending--;
+        if (exists) {
+          resolve(pathToCheck);
+          return;
+        }
+        if (!pending) {
+          resolve(undefined);
+        }
+      });
+    }
+  });
+};
+var searchConfigPath = async (pathOverride) => {
+  let activeDir = process.cwd();
+  if (isDefined(pathOverride)) {
+    if (isAbsolute(pathOverride)) {
+      return pathOverride;
+    }
+    return join(activeDir, pathOverride);
+  }
+  let trackDist = 0;
+  while (!isRootDir(activeDir)) {
+    if (trackDist > dirDistLimit) {
+      throw new Error(`Maximum config search directory distance reached (${dirDistLimit.toString()}).`);
+    }
+    const configPath = await checkForConfigInDir(activeDir);
+    if (configPath) {
+      return configPath;
+    }
+    trackDist++;
+    activeDir = dirname2(activeDir);
+  }
+  return checkForConfigInDir(activeDir);
+};
+
+// src/lib/configuration/functions/load-config.ts
+var defaultConfig = {
+  packages: "packages/*",
+  version: {
+    preId: "",
+    exact: false
+  },
+  watch: {
+    debounceMs: 500,
+    hooks: {
+      onBeforeProcessPackage: noOp2,
+      onProcessPackage: noOp2,
+      onProcessPackageError: noOp2,
+      onAfterProcessPackage: noOp2,
+      onBeforePackagesReady: noOp2,
+      onPackagesReady: noOp2,
+      onAfterPackagesReady: noOp2
+    },
+    subprocess: {
+      partialProcessing: false,
+      parallelProcessing: true,
+      matchLongRunningOutputAsReady: null,
+      matchLongRunningOutputAsErrored: null
+    }
+  },
+  logger: getDefaultLogger("info"),
+  logLevel: "info"
+};
+var loadConfig = async (overrideConfigPath) => {
+  const path = await searchConfigPath(overrideConfigPath);
+  if (!path) {
+    defaultConfig.logger.info("No config file found. Defaults will be applied.");
+    return defaultConfig;
+  }
+  const parsedConfig = await parseConfig(path);
+  const parsedLogger = parsedConfig["logger"];
+  const logger = parsedLogger ?? (!parsedConfig.logLevel || parsedConfig.logLevel === defaultConfig.logLevel ? defaultConfig.logger : getDefaultLogger(parsedConfig.logLevel));
+  logger.info(`Successfully loaded config file '${path}'.`);
+  logger.debug(dim(bgGray("User config:")), `
+${dim(formatSimpleLogObject(parsedConfig))}`);
+  logger.debug(dim(bgGray("Default config:")), `
+${dim(formatSimpleLogObject(defaultConfig))}`);
+  const activatedConfig = deepMergeDefined(defaultConfig, parsedConfig);
+  activatedConfig.logger = logger;
+  logger.debug(dim(bgGray("Activated config:")), `
+${dim(formatSimpleLogObject(activatedConfig))}`);
+  return activatedConfig;
+};
+
+// src/lib/graph/functions/generate-graphs.ts
+import { assertDefined as assertDefined2 } from "@package-pal/util";
+import { dim as dim2 } from "yoctocolors";
+var trackPackageEntryDependencies = ({
+  trackedDependencies,
+  packageNames,
+  packageData
+}) => {
+  const iterateEntries = [packageData.dependencies, packageData.peerDependencies];
+  for (const packageEntries of iterateEntries) {
+    if (!packageEntries) {
+      continue;
+    }
+    for (const trackPackageName of Object.keys(packageEntries)) {
+      if (!packageNames.has(trackPackageName)) {
+        continue;
+      }
+      trackedDependencies.add(trackPackageName);
+    }
+  }
+};
+var generateReverseGraph = (packages, packageGraph) => {
+  const reversePackageGraph = new Map(packages.map((packageData) => [packageData.name, {
+    packageData,
+    pointsToPackages: new Set
+  }]));
+  for (const packageData of packages) {
+    const packageNode = assertDefined2(packageGraph.get(packageData.name));
+    for (const dependency of packageNode.pointsToPackages) {
+      const reverseNode = assertDefined2(reversePackageGraph.get(dependency));
+      reverseNode.pointsToPackages.add(packageData.name);
+    }
+  }
+  return reversePackageGraph;
+};
+var generateGraphs = (packages, logger) => {
+  logger.debug(dim2(`Generating package graphs for ${packages.length.toString()} packages...`));
+  const packageNames = new Set(packages.map((packageData) => packageData.name));
+  const packageGraph = new Map;
+  for (const packageData of packages) {
+    const trackedDependencies = new Set;
+    trackPackageEntryDependencies({
+      trackedDependencies,
+      packageNames,
+      packageData
+    });
+    packageGraph.set(packageData.name, {
+      packageData,
+      pointsToPackages: trackedDependencies
+    });
+  }
+  const reversePackageGraph = generateReverseGraph(packages, packageGraph);
+  return {
+    dependencies: packageGraph,
+    dependents: reversePackageGraph
+  };
+};
+
+// src/lib/graph/functions/generate-package-circular-dependency-paths.ts
+import { assertDefined as assertDefined6 } from "@package-pal/util";
+import {
+  dim as dim3,
+  yellow
+} from "yoctocolors";
+
+// src/lib/graph/functions/dfs-traverse-graph-paths.ts
+import { assertDefined as assertDefined3 } from "@package-pal/util";
+var dfsTraverseGraphPaths = function* (graph, traverseFromPackages) {
+  const globalVisited = new Set;
+  const startPackages = Array.isArray(traverseFromPackages) ? traverseFromPackages : [traverseFromPackages];
+  for (const start of startPackages) {
+    const stack = [{
+      node: start,
+      path: [],
+      localVisited: new Set
+    }];
+    while (stack.length) {
+      const {
+        node,
+        path,
+        localVisited
+      } = assertDefined3(stack.pop());
+      if (localVisited.has(node)) {
+        const idx = path.indexOf(node);
+        if (idx !== -1) {
+          yield [...path.slice(idx), node];
+        }
+        continue;
+      }
+      if (globalVisited.has(node)) {
+        continue;
+      }
+      const newPath = [...path, node];
+      const newLocalVisited = new Set(localVisited);
+      newLocalVisited.add(node);
+      const neighbours = graph.get(node)?.pointsToPackages;
+      let pushed = false;
+      if (neighbours) {
+        for (const neighbour of neighbours) {
+          stack.push({
+            node: neighbour,
+            path: newPath,
+            localVisited: newLocalVisited
+          });
+          pushed = true;
+        }
+      }
+      if (!pushed) {
+        yield newPath;
+      }
+      globalVisited.add(node);
+    }
+  }
+};
+
+// src/lib/graph/functions/extract-subgraph.ts
+import { assertDefined as assertDefined5 } from "@package-pal/util";
+
+// src/lib/graph/functions/dfs-traverse-graph.ts
+import { assertDefined as assertDefined4 } from "@package-pal/util";
+var dfsTraverseGraph = function* (graph, traverseFromPackages) {
+  const visited = new Set;
+  const stack = Array.isArray(traverseFromPackages) ? [...traverseFromPackages] : [traverseFromPackages];
+  while (stack.length) {
+    const activePackage = assertDefined4(stack.pop());
+    if (visited.has(activePackage)) {
+      continue;
+    }
+    visited.add(activePackage);
+    const node = graph.get(activePackage);
+    if (!node) {
+      continue;
+    }
+    yield node.packageData;
+    for (const dep of node.pointsToPackages) {
+      if (!visited.has(dep)) {
+        stack.push(dep);
+      }
+    }
+  }
+};
+
+// src/lib/graph/functions/extract-subgraph.ts
+var extractSubgraph = (graph, fromPackages) => {
+  const reachablePackages = new Set(dfsTraverseGraph(graph, fromPackages).map((packageData) => packageData.name));
+  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)));
+    subgraph.set(packageName, {
+      packageData: node.packageData,
+      pointsToPackages: filteredNeighbours
+    });
+  }
+  return subgraph;
+};
+
+// src/lib/graph/functions/generate-package-circular-dependency-paths.ts
+var findStronglyConnectedComponents = (graph) => {
+  let index = 0;
+  const indices = new Map;
+  const lowlinks = new Map;
+  const stack = [];
+  const onStack = new Set;
+  const sccs = [];
+  const strongConnect = (node) => {
+    indices.set(node, index);
+    lowlinks.set(node, index);
+    index++;
+    stack.push(node);
+    onStack.add(node);
+    const neighbors = graph.get(node)?.pointsToPackages ?? new Set;
+    for (const neighbor of neighbors) {
+      if (!indices.has(neighbor)) {
+        strongConnect(neighbor);
+        lowlinks.set(node, Math.min(assertDefined6(lowlinks.get(node)), assertDefined6(lowlinks.get(neighbor))));
+        continue;
+      }
+      if (onStack.has(neighbor)) {
+        lowlinks.set(node, Math.min(assertDefined6(lowlinks.get(node)), assertDefined6(indices.get(neighbor))));
+      }
+    }
+    if (lowlinks.get(node) === indices.get(node)) {
+      const scc = [];
+      let stackNode = assertDefined6(stack.pop());
+      onStack.delete(stackNode);
+      scc.push(stackNode);
+      while (stackNode !== node) {
+        stackNode = assertDefined6(stack.pop());
+        onStack.delete(stackNode);
+        scc.push(stackNode);
+      }
+      const firstNode = scc[0];
+      const isSelfCycle = !!firstNode && (graph.get(firstNode)?.pointsToPackages.has(firstNode) ?? false);
+      if (scc.length > 1 || isSelfCycle) {
+        sccs.push(scc);
+      }
+    }
+  };
+  for (const node of graph.keys()) {
+    if (!indices.has(node)) {
+      strongConnect(node);
+    }
+  }
+  return sccs;
+};
+var findSampleCyclePath = (scc, graph) => {
+  const sccSet = new Set(scc);
+  return assertDefined6(dfsTraverseGraphPaths(graph, scc).find((path) => {
+    const lastPackage = path[path.length - 1];
+    return path.length >= 2 && lastPackage && sccSet.has(lastPackage);
+  }));
+};
+var generatePackageCircularDependencyPaths = ({ dependents }, packageSorted, logger) => {
+  logger.debug(dim3("Generating circular dependency paths..."));
+  const subgraph = extractSubgraph(dependents, packageSorted.circular);
+  const scss = findStronglyConnectedComponents(subgraph);
+  const sampleCycles = scss.map((scc) => findSampleCyclePath(scc, subgraph).reverse());
+  if (sampleCycles.length) {
+    const sampleCycleContents = sampleCycles.map((cycle, index) => {
+      return `	${(index + 1).toString()}. ` + cycle.map((name) => `'${name}'`).join(" \u2192 ");
+    }).join(`
+`);
+    logger.warn(yellow(`${sampleCycles.length.toString()} cyclic paths found:
+${sampleCycleContents}`));
+  } else {
+    logger.debug(dim3(`No cyclic paths found.`));
+  }
+  return sampleCycles;
+};
+
+// src/lib/graph/functions/generate-topological-sorted-groups.ts
+import { assertDefined as assertDefined7 } from "@package-pal/util";
+import {
+  dim as dim4,
+  yellow as yellow2
+} from "yoctocolors";
+var getCircularDependencies = (inDegree) => {
+  return Array.from(inDegree.keys()).sort((a, b) => {
+    const degA = assertDefined7(inDegree.get(a));
+    const degB = assertDefined7(inDegree.get(b));
+    return degB - degA;
+  }).sort();
+};
+var generateTopologicalSortedGroups = (packageGraph, logger) => {
+  logger.debug(dim4("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) {
+    for (const dependencyName of node.pointsToPackages) {
+      assertDefined7(graph.get(dependencyName)).add(packageName);
+      inDegree.set(packageName, assertDefined7(inDegree.get(packageName)) + 1);
+    }
+  }
+  const result = [];
+  let ready = [];
+  for (const [packageName, deg] of inDegree) {
+    if (deg === 0) {
+      ready.push(packageName);
+    }
+  }
+  while (ready.length > 0) {
+    result.push(ready);
+    const nextReady = [];
+    for (const packageName of ready) {
+      inDegree.delete(packageName);
+      const dependentPackages = graph.get(packageName);
+      if (!dependentPackages) {
+        continue;
+      }
+      for (const dependentPackage of dependentPackages) {
+        inDegree.set(dependentPackage, assertDefined7(inDegree.get(dependentPackage)) - 1);
+        if (inDegree.get(dependentPackage) === 0) {
+          nextReady.push(dependentPackage);
+        }
+      }
+    }
+    ready = nextReady;
+  }
+  logger.debug(dim4(`Sorted packages into ${result.length.toString()} sequential groups of parallelizable dependencies.`));
+  const circular = getCircularDependencies(inDegree);
+  if (circular.length) {
+    logger.warn(yellow2(`${circular.length.toString()} packages could not be sorted due to circular dependencies. Correct ordering cannot be guaranteed.`));
+  }
+  return {
+    groups: result.map((group) => group.sort()),
+    circular
+  };
+};
+
+// src/lib/package/functions/load-packages.ts
+import { dim as dim6 } from "yoctocolors";
+
+// src/lib/package/functions/scan-packages.ts
+import {
+  dirname as dirname4,
+  join as join2
+} from "path";
+import { formatUnknownError } from "@package-pal/util";
+import {
+  dim as dim5,
+  red
+} from "yoctocolors";
+
+// src/lib/package/functions/parse-package.ts
+import {
+  dirname as dirname3,
+  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;
+  if (isDefined2(dependencies) && !(typeof dependencies === "object") || isDefined2(peerDependencies) && !(typeof peerDependencies === "object") || isDefined2(devDependencies) && !(typeof devDependencies === "object")) {
+    return;
+  }
+  return {
+    rawContent: text,
+    path,
+    name: props.name ?? path,
+    dir: basename2(dirname3(path)),
+    version: props.version ?? undefined,
+    dependencies: dependencies ?? undefined,
+    peerDependencies: peerDependencies ?? undefined,
+    devDependencies: devDependencies ?? undefined
+  };
+};
+
+// src/lib/package/functions/scan-package-paths.ts
+import { scanGlobPatternPaths } from "@package-pal/util";
+var scanPackagePaths = (packages) => {
+  return scanGlobPatternPaths(packages, {
+    absolute: true,
+    onlyFiles: false
+  });
+};
+
+// src/lib/package/functions/scan-packages.ts
+var scanPackages = async function* (patterns, logger) {
+  for await (const path of scanPackagePaths(patterns)) {
+    const packagePath = join2(path, "package.json");
+    const dir = dirname4(packagePath);
+    try {
+      const file = Bun.file(packagePath);
+      const text = await file.text();
+      const packageData = parsePackage(packagePath, text);
+      if (!packageData) {
+        logger.debug(dim5(`Invalid package.json found in '${dir}'.`));
+        continue;
+      }
+      logger.debug(dim5(`Successfully read package.json in '${dir}'.`));
+      yield packageData;
+    } catch (e) {
+      logger.debug(dim5(`Failed to read package.json in '${dir}' - ${red(formatUnknownError(e))}.`));
+    }
+  }
+};
+
+// src/lib/package/functions/load-packages.ts
+var loadPackages = async (packagePatterns, logger) => {
+  const patternContent = packagePatterns.map((pattern) => `'${pattern}'`).join(", ");
+  logger.debug(dim6(`Loading packages matching pattern/s ${patternContent}...`));
+  const packages = [];
+  const seen = new Set;
+  for await (const packageData of scanPackages(Array.from(new Set(packagePatterns)), logger)) {
+    if (seen.has(packageData.name)) {
+      continue;
+    }
+    seen.add(packageData.name);
+    packages.push(packageData);
+  }
+  if (!packages.length) {
+    throw new Error(`No packages found for pattern/s ${patternContent}.`);
+  }
+  return packages;
+};
+
+// src/lib/package/functions/update-package-version.ts
+var {semver } = globalThis.Bun;
+import { inc } from "semver";
+import { dim as dim7 } from "yoctocolors";
+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(dim7(`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) => {
+    const fields = ["dependencies", "peerDependencies"];
+    return fields.flatMap((field) => {
+      const entry = dependent[field];
+      const depVersion = entry?.[packageName];
+      if (!depVersion) {
+        return [];
+      }
+      if (exact ? depVersion === bumpedVersion : semver.satisfies(bumpedVersion, depVersion)) {
+        logger.debug(dim7(`Skipping '${dependent.name}': ${field} version '${depVersion}' already satisfies '${bumpedVersion}'.`));
+        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;
+  });
+};
+
+// src/lib/watch/functions/watch-package-changes.ts
+import {
+  watch
+} from "fs";
+import {
+  dirname as dirname6,
+  join as join4
+} from "path";
+import {
+  assertDefined as assertDefined9,
+  DedupePathsBy,
+  dedupeSharedPaths,
+  getDeferredPromise,
+  getStringMatcher,
+  isDefined as isDefined4
+} from "@package-pal/util";
+import {
+  dim as dim9,
+  red as red3
+} from "yoctocolors";
+
+// src/lib/graph/functions/generate-topological-ranking-range.ts
+import { isDefined as isDefined3 } 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)) {
+      continue;
+    }
+    if (rank < min) {
+      min = rank;
+    }
+    if (rank > max) {
+      max = rank;
+    }
+  }
+  if (min === Infinity) {
+    return [-1, -1];
+  }
+  return [min, max];
+};
+
+// src/lib/graph/functions/generate-topological-ranking.ts
+import { assertDefined as assertDefined8 } from "@package-pal/util";
+var generateTopologicalRanking = (packageProcessOrder) => {
+  const rankMap = new Map;
+  for (let i = 0;i < packageProcessOrder.length; i++) {
+    for (const packageName of assertDefined8(packageProcessOrder[i])) {
+      rankMap.set(packageName, i);
+    }
+  }
+  return rankMap;
+};
+
+// src/lib/graph/functions/is-disjoint.ts
+var isDisjoint = (a, b) => {
+  for (const key of a.keys()) {
+    if (b.has(key)) {
+      return false;
+    }
+  }
+  return true;
+};
+
+// src/lib/graph/functions/is-ranked-greater-than-or-equal.ts
+var isRankedGreaterThanOrEqual = (a, b, ranking) => {
+  const [prevMin] = generateTopologicalRankingRange(a, ranking);
+  for (const key of b.keys()) {
+    const rank = ranking.get(key);
+    if (rank !== undefined && rank < prevMin) {
+      return false;
+    }
+  }
+  return true;
+};
+
+// src/lib/graph/functions/is-subgraph.ts
+var recordEqual = (a, b) => {
+  if (!a && !b) {
+    return true;
+  }
+  if (!a || !b) {
+    return false;
+  }
+  const aKeys = Object.keys(a);
+  const bKeys = Object.keys(b);
+  if (aKeys.length !== bKeys.length) {
+    return false;
+  }
+  return aKeys.every((key) => b[key] === a[key]);
+};
+var isPackageDataLooseEqual = (a, b) => {
+  return a.name === b.name && recordEqual(a.dependencies, b.dependencies) && recordEqual(a.peerDependencies, b.peerDependencies) && recordEqual(a.devDependencies, b.devDependencies);
+};
+var isSubgraph = (a, b) => {
+  for (const [key, nodeB] of b) {
+    const nodeA = a.get(key);
+    if (!nodeA) {
+      return false;
+    }
+    if (!isPackageDataLooseEqual(nodeA.packageData, nodeB.packageData)) {
+      return false;
+    }
+    for (const dep of nodeB.pointsToPackages) {
+      if (!nodeA.pointsToPackages.has(dep)) {
+        return false;
+      }
+    }
+  }
+  return true;
+};
+
+// src/lib/watch/types/change-action.ts
+var ChangeAction = {
+  Ignore: "Ignore",
+  Partial: "Partial",
+  Restart: "Restart"
+};
+
+// src/lib/watch/types/exit-state.ts
+var ExitState = {
+  Completed: "Completed",
+  Errored: "Errored",
+  Cancelled: "Cancelled"
+};
+
+// src/lib/watch/types/run-async-type.ts
+var RunAsyncType = {
+  Sequential: "Sequential",
+  Parallel: "Parallel"
+};
+
+// src/lib/watch/functions/filter-files-modified-since.ts
+var filterFilesModifiedSince = (paths, sinceMs) => {
+  return paths.filter((path) => {
+    const changedFile = Bun.file(path);
+    return changedFile.lastModified >= sinceMs;
+  });
+};
+
+// src/lib/watch/functions/normalise-watched-file-path.ts
+import {
+  basename as basename3,
+  dirname as dirname5,
+  join as join3
+} from "path";
+var removeTrailing = [
+  "~",
+  ".tmp",
+  ".temp",
+  ".bak",
+  ".backup",
+  ".swp",
+  ".swo",
+  ".swn"
+];
+var normaliseWatchedFilePath = (filePath) => {
+  const dir = dirname5(filePath);
+  let base = basename3(filePath);
+  for (const trailing of removeTrailing) {
+    if (base.toLowerCase().endsWith(trailing)) {
+      const sliceStart = base.startsWith(".") ? 1 : 0;
+      base = base.slice(sliceStart, -trailing.length);
+      break;
+    }
+  }
+  return join3(dir, base);
+};
+
+// src/lib/watch/functions/run-async.ts
+var runAsync = async (type, tasks) => {
+  if (type === RunAsyncType.Parallel) {
+    return Promise.all(tasks.map((task) => task()));
+  }
+  const outputs = [];
+  for (const task of tasks) {
+    const result = await task();
+    outputs.push(result);
+  }
+  return outputs;
+};
+
+// src/lib/watch/functions/run-subprocess.ts
+import {
+  dim as dim8,
+  red as red2
+} from "yoctocolors";
+
+// src/lib/watch/types/std-type.ts
+var StdType = {
+  Out: "Out",
+  Err: "Err"
+};
+
+// src/lib/watch/functions/get-commands-for-shell.ts
+var getCommandsForShell = (shellCommand) => {
+  const isWindows = process.platform === "win32";
+  if (!isWindows) {
+    return [
+      "sh",
+      "-c",
+      `"${shellCommand}"`
+    ];
+  }
+  const shell = Bun.which("pwsh") ? "pwsh" : Bun.which("powershell") ? "powershell" : "cmd";
+  if (shell === "cmd") {
+    return [
+      shell,
+      "/c",
+      `"${shellCommand}"`
+    ];
+  }
+  const encodedCommand = Buffer.from(shellCommand, "utf16le").toString("base64");
+  return [
+    shell,
+    "-EncodedCommand",
+    encodedCommand
+  ];
+};
+
+// src/lib/watch/functions/get-line-buffered-writer.ts
+import { identity } from "@package-pal/util";
+var getLineBufferedWriter = (prefix, style = identity, write = process.stdout.write.bind(process.stdout)) => {
+  let buffer = "";
+  return (chunk) => {
+    buffer += chunk;
+    const lines = buffer.split(`
+`);
+    buffer = lines.pop() ?? "";
+    for (const line of lines) {
+      write(`${prefix}${style(line)}
+`);
+    }
+  };
+};
+
+// src/lib/watch/functions/read-stream.ts
+var readStream = async (stream, use) => {
+  if (!stream) {
+    return;
+  }
+  const decoder = new TextDecoder;
+  const reader = stream.getReader();
+  let result = await reader.read();
+  while (!result.done) {
+    use(decoder.decode(result.value, { stream: true }));
+    result = await reader.read();
+  }
+  const flush = decoder.decode();
+  if (flush) {
+    use(flush);
+  }
+};
+
+// src/lib/watch/functions/run-subprocess.ts
+var sigintCode = 130;
+var sigtermCode = 143;
+var sigkillCode = 137;
+var cancelCodes = new Set([
+  sigintCode,
+  sigtermCode,
+  sigkillCode
+]);
+var runSubprocess = async (opts) => {
+  if (opts.signal?.aborted) {
+    opts.logger.debug(dim8(`Skipped '${opts.debugName}' subprocess command; signal already cancelled.`));
+    return ExitState.Cancelled;
+  }
+  const commands = getCommandsForShell(opts.shellCommand);
+  const subprocess = Bun.spawn(commands, {
+    cwd: opts.cwd,
+    stdout: "pipe",
+    stderr: "pipe",
+    stdin: "ignore",
+    signal: opts.signal
+  });
+  const pid = subprocess.pid.toString();
+  const [readStdout, readStderr] = [{
+    source: subprocess.stdout,
+    type: StdType.Out,
+    write: getLineBufferedWriter(dim8(`[OUT-${pid}]	`))
+  }, {
+    source: subprocess.stderr,
+    type: StdType.Err,
+    write: getLineBufferedWriter(red2(dim8(`[ERR-${pid}]	`)))
+  }].map(({
+    source,
+    type,
+    write
+  }) => {
+    return readStream(source, (chunk) => {
+      write(chunk);
+      if (opts.onStdChunk) {
+        opts.onStdChunk(chunk, type);
+      }
+    });
+  });
+  const executedCommand = commands.join(" ");
+  opts.logger.debug(dim8(`Started '${opts.debugName}' subprocess command '${opts.shellCommand}' (${executedCommand}) with PID ${pid}.`));
+  const [
+    ,
+    ,
+    exitState
+  ] = await Promise.all([
+    readStdout,
+    readStderr,
+    subprocess.exited.then((exitCode) => {
+      if (cancelCodes.has(exitCode)) {
+        opts.logger.debug(dim8(`Cancelled '${opts.debugName}' subprocess command; PID ${pid} exited.`));
+        return ExitState.Cancelled;
+      }
+      if (exitCode !== 0) {
+        opts.logger.error(red2(`'${opts.debugName}' command '${opts.shellCommand}' (${executedCommand}) with PID ${pid} failed with exit code ${exitCode.toString()}.`));
+        return ExitState.Errored;
+      }
+      opts.logger.debug(dim8(`Completed '${opts.debugName}' subprocess command; PID ${pid} exited.`));
+      return ExitState.Completed;
+    })
+  ]);
+  return exitState;
+};
+
+// src/lib/watch/functions/watch-package-changes.ts
+var fileModifiedThresholdMs = 5000;
+var lastProcessedSubgraph;
+var getChangeLogic = (packageGraphs, packageChanges, config, logger) => {
+  const changedPackages = Array.from(packageChanges.keys());
+  const changedFilePaths = Array.from(packageChanges.values()).flat();
+  if (packageChanges.size) {
+    logger.debug(dim9(`Changes detected in ${changedPackages.map((packageName) => `'${packageName}'`).join(", ")}.`));
+    logger.debug(dim9(`Changed file paths: ${changedFilePaths.map((filePath) => `'${filePath}'`).join(", ")}.`));
+  }
+  const packageOrder = generateTopologicalSortedGroups(packageGraphs.dependents, logger);
+  const packageProcessOrder = packageOrder.groups.toReversed().concat(packageOrder.circular);
+  const packageRankings = generateTopologicalRanking(packageProcessOrder);
+  const changedPackageSubgraph = extractSubgraph(packageGraphs.dependents, changedPackages);
+  const changedPackageOrder = generateTopologicalSortedGroups(changedPackageSubgraph, logger);
+  const changedPackageProcessOrder = changedPackageOrder.groups.toReversed().concat(changedPackageOrder.circular);
+  const isSubgraphOfPrevious = !!lastProcessedSubgraph && isSubgraph(lastProcessedSubgraph, changedPackageSubgraph);
+  const isDisjointFromPrevious = !lastProcessedSubgraph || !isSubgraphOfPrevious && isDisjoint(lastProcessedSubgraph, changedPackageSubgraph);
+  const isRankedGreaterThanOrEqualToPrevious = !!lastProcessedSubgraph && !isSubgraphOfPrevious && isRankedGreaterThanOrEqual(lastProcessedSubgraph, changedPackageSubgraph, packageRankings);
+  logger.debug(dim9(`Changes are subgraph of previous: ${isSubgraphOfPrevious.toString()}.`));
+  logger.debug(dim9(`Changes are disjoint from previous: ${isDisjointFromPrevious.toString()}.`));
+  logger.debug(dim9(`Changes are ranked greater than or equal to previous: ${isRankedGreaterThanOrEqualToPrevious.toString()}.`));
+  let action = ChangeAction.Restart;
+  if (!packageChanges.size) {
+    action = ChangeAction.Ignore;
+  } else if (!config.subprocess.partialProcessing) {
+    action = ChangeAction.Restart;
+  } else if (isSubgraphOfPrevious) {
+    action = ChangeAction.Ignore;
+  } else if (isDisjointFromPrevious || isRankedGreaterThanOrEqualToPrevious) {
+    action = ChangeAction.Partial;
+  }
+  if (action === ChangeAction.Partial && isRankedGreaterThanOrEqualToPrevious) {
+    const [prevMinRank] = generateTopologicalRankingRange(assertDefined9(lastProcessedSubgraph), packageRankings);
+    for (let i = 0;i < changedPackageProcessOrder.length; i++) {
+      changedPackageProcessOrder[i] = assertDefined9(changedPackageProcessOrder[i]).filter((packageName) => {
+        const rank = packageRankings.get(packageName);
+        return rank !== undefined && rank >= prevMinRank;
+      });
+    }
+  }
+  logger.debug(dim9(`Determined change action: ${action}.`));
+  return {
+    changedPackageProcessOrder,
+    changedPackageSubgraph,
+    action
+  };
+};
+var onProcessPackage = async (packageGraphs, packageChanges, watchConfig, determineAbortController, logger) => {
+  const {
+    action,
+    changedPackageProcessOrder,
+    changedPackageSubgraph
+  } = getChangeLogic(packageGraphs, packageChanges, watchConfig, logger);
+  const controller = determineAbortController(action === ChangeAction.Restart);
+  const onProcessFailure = () => {
+    logger.debug(dim9("Aborting controller: process failed."));
+    controller.abort();
+    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(`Changes detected. ${action === ChangeAction.Restart ? "Restarting processing" : "Initiating partial processing"} ${watchConfig.subprocess.parallelProcessing ? "in parallel" : "sequentially"}.`);
+    lastProcessedSubgraph = changedPackageSubgraph;
+  }
+  for (const group of changedPackageProcessOrder) {
+    const {
+      promise: longRunningParallelProcessReady,
+      resolve: matchedParallelLongReadyRunningOutput
+    } = getDeferredPromise();
+    let matchedLongRunningOutputCount = 0;
+    await runAsync(watchConfig.subprocess.parallelProcessing ? RunAsyncType.Parallel : RunAsyncType.Sequential, group.map((packageName) => async () => {
+      const {
+        promise: longRunningSequentialProcessReady,
+        resolve: matchedSequentialLongRunningReadyOutput
+      } = getDeferredPromise();
+      const packageNode = assertDefined9(packageGraphs.dependencies.get(packageName));
+      const changedPaths = packageChanges.get(packageName) ?? [];
+      const processPackageProps = {
+        name: packageName,
+        dir: packageNode.packageData.dir,
+        filePaths: changedPaths,
+        totalChanges: packageChanges,
+        totalProcessOrder: changedPackageProcessOrder,
+        signal: controller.signal
+      };
+      const processPackageCwd = dirname6(packageNode.packageData.path);
+      const beforeProcessPackageShellCommand = await watchConfig.hooks.onBeforeProcessPackage(processPackageProps);
+      if (beforeProcessPackageShellCommand) {
+        await runSubprocess({
+          debugName: `before process ${packageName}`,
+          shellCommand: beforeProcessPackageShellCommand,
+          cwd: processPackageCwd,
+          signal: controller.signal,
+          logger
+        });
+      }
+      const processPackageShellCommand = await watchConfig.hooks.onProcessPackage(processPackageProps);
+      if (processPackageShellCommand) {
+        const longRunningOutputReadyText = watchConfig.subprocess.matchLongRunningOutputAsReady;
+        const longRunningOutputErroredText = watchConfig.subprocess.matchLongRunningOutputAsErrored;
+        const readyMatcher = longRunningOutputReadyText ? getStringMatcher(longRunningOutputReadyText) : undefined;
+        const erroredMatcher = longRunningOutputErroredText ? getStringMatcher(longRunningOutputErroredText) : undefined;
+        let ready = false;
+        let errored = false;
+        const exit = runSubprocess({
+          debugName: `process ${packageName}`,
+          shellCommand: processPackageShellCommand,
+          cwd: processPackageCwd,
+          signal: controller.signal,
+          logger,
+          onStdChunk: (chunk) => {
+            if (!ready && readyMatcher?.push(chunk).matched()) {
+              ready = true;
+              matchedLongRunningOutputCount++;
+              logger.debug(`'${packageName}' (${matchedLongRunningOutputCount.toString()}/${group.length.toString()}) subprocess matched ready text '${assertDefined9(longRunningOutputReadyText)}'.`);
+              if (!watchConfig.subprocess.parallelProcessing && matchedLongRunningOutputCount) {
+                matchedSequentialLongRunningReadyOutput();
+              }
+            }
+            if (!errored && erroredMatcher?.push(chunk).matched()) {
+              logger.error(red3(`'${packageName}' subprocess matched error text '${assertDefined9(longRunningOutputErroredText)}'.`));
+              errored = true;
+              Promise.resolve(watchConfig.hooks.onProcessPackageError(processPackageProps)).then((processPackageErrorCommand) => {
+                if (!processPackageErrorCommand) {
+                  onProcessFailure();
+                  return;
+                }
+                return runSubprocess({
+                  debugName: `after process ${packageName}`,
+                  shellCommand: processPackageErrorCommand,
+                  cwd: processPackageCwd,
+                  signal: controller.signal,
+                  logger
+                });
+              }).then((exitState) => {
+                if (exitState === ExitState.Errored) {
+                  onProcessFailure();
+                }
+              });
+            }
+            if (watchConfig.subprocess.parallelProcessing && matchedLongRunningOutputCount === group.length) {
+              matchedParallelLongReadyRunningOutput();
+            }
+          }
+        }).then((exitState) => {
+          if (exitState === ExitState.Errored) {
+            onProcessFailure();
+          }
+        });
+        await Promise.race([
+          longRunningParallelProcessReady,
+          longRunningSequentialProcessReady,
+          exit
+        ]);
+      }
+      const afterProcessPackageShellCommand = await watchConfig.hooks.onAfterProcessPackage(processPackageProps);
+      if (afterProcessPackageShellCommand) {
+        await runSubprocess({
+          debugName: `after process ${packageName}`,
+          shellCommand: afterProcessPackageShellCommand,
+          cwd: processPackageCwd,
+          signal: controller.signal,
+          logger
+        });
+      }
+    }));
+  }
+  if (packageChanges.size) {
+    logger.info(`Processing ${controller.signal.aborted ? "cancelled due to new changes" : "completed"}.`);
+  }
+  const packagesReadyProps = {
+    totalChanges: packageChanges,
+    totalProcessOrder: changedPackageProcessOrder,
+    signal: controller.signal
+  };
+  const beforePackagesReadyShellCommand = await watchConfig.hooks.onBeforePackagesReady(packagesReadyProps);
+  if (beforePackagesReadyShellCommand) {
+    await runSubprocess({
+      debugName: "before packages ready",
+      shellCommand: beforePackagesReadyShellCommand,
+      signal: controller.signal,
+      logger
+    });
+  }
+  const packagesReadyShellCommand = await watchConfig.hooks.onPackagesReady(packagesReadyProps);
+  if (packagesReadyShellCommand) {
+    await runSubprocess({
+      debugName: "packages ready",
+      shellCommand: packagesReadyShellCommand,
+      signal: controller.signal,
+      logger
+    });
+  }
+  const afterPackagesReadyShellCommand = await watchConfig.hooks.onAfterPackagesReady(packagesReadyProps);
+  if (afterPackagesReadyShellCommand) {
+    await runSubprocess({
+      debugName: "after packages ready",
+      shellCommand: afterPackagesReadyShellCommand,
+      logger
+    });
+  }
+};
+var watchPackageChanges = (packageData, packageGraphs, watchConfig, logger) => {
+  const dedupedRootPackageData = dedupeSharedPaths(packageData.map((packageData2) => packageData2.path), DedupePathsBy.Parent).map((packagePath) => assertDefined9(packageData.find((data) => data.path === packagePath)));
+  logger.debug(dim9(`Starting ${dedupedRootPackageData.length.toString()} watchers for ${packageData.length.toString()} packages.`));
+  let closed = false;
+  let debounceTimeout;
+  let startedDebounceMs;
+  let abortController;
+  const changedPackagePaths = new Map;
+  const useController = (reset) => {
+    if (abortController && (reset || abortController.signal.aborted)) {
+      if (reset) {
+        logger.debug(dim9("Aborting controller: reset for new packages."));
+        abortController.abort();
+      }
+      abortController = undefined;
+    }
+    abortController ??= new AbortController;
+    return abortController;
+  };
+  const onWatchEvent = (watchPath, packageName, _event, filePath, forceEmpty = false) => {
+    if (!isDefined4(startedDebounceMs)) {
+      startedDebounceMs = Date.now();
+    }
+    if (debounceTimeout) {
+      clearTimeout(debounceTimeout);
+    }
+    if (packageName && watchPath && filePath) {
+      const changedPath = join4(watchPath, normaliseWatchedFilePath(filePath));
+      const existingPaths = changedPackagePaths.get(packageName);
+      if (existingPaths) {
+        existingPaths.add(changedPath);
+      } else {
+        changedPackagePaths.set(packageName, new Set([changedPath]));
+      }
+    }
+    debounceTimeout = setTimeout(() => {
+      if (closed) {
+        return;
+      }
+      const packageChanges = new Map;
+      for (const [packageName2, paths] of changedPackagePaths) {
+        const processedPaths = filterFilesModifiedSince(dedupeSharedPaths(Array.from(paths), DedupePathsBy.Child).sort(), assertDefined9(startedDebounceMs) - fileModifiedThresholdMs);
+        if (processedPaths.length) {
+          packageChanges.set(packageName2, processedPaths);
+        }
+      }
+      startedDebounceMs = undefined;
+      changedPackagePaths.clear();
+      if (!packageChanges.size && !forceEmpty) {
+        return;
+      }
+      onProcessPackage(packageGraphs, packageChanges, watchConfig, (reset) => useController(reset), logger);
+    }, watchConfig.debounceMs);
+  };
+  const watchers = dedupedRootPackageData.map(({
+    name,
+    path
+  }) => {
+    const watchPath = dirname6(path);
+    return watch(watchPath, { recursive: true }, (event, filePath) => {
+      onWatchEvent(watchPath, name, event, filePath);
+    });
+  });
+  const closeWatchers = () => {
+    watchers.forEach((watcher) => {
+      watcher.close();
+    });
+    logger.debug(dim9("Aborting controller: closing watchers."));
+    abortController?.abort();
+    closed = true;
+  };
+  process.on("SIGINT", () => {
+    logger.debug(dim9("Received SIGINT: closing watchers."));
+    closeWatchers();
+    process.exit(0);
+  });
+  onWatchEvent(undefined, undefined, undefined, null, true);
+  return { close: () => {
+    if (closed) {
+      logger.debug(dim9("Watchers already closed."));
+      return;
+    }
+    logger.debug(dim9("Closing watchers."));
+    closeWatchers();
+  } };
+};
+
+// src/lib/api.ts
+var readPackagePalConfig = (options) => {
+  checkBun();
+  return loadConfig(options?.overrideConfigPath);
+};
+var readPackageData = async (options) => {
+  checkBun();
+  const packagePatterns = Array.isArray(options.config.packages) ? options.config.packages : [options.config.packages];
+  return loadPackages(packagePatterns, options.config.logger);
+};
+var getPackageGraphs = (options) => {
+  checkBun();
+  return generateGraphs(options.packageData, options.config.logger);
+};
+var getPackageOrder = (options) => {
+  checkBun();
+  return generateTopologicalSortedGroups(options.packageGraphs.dependencies, options.config.logger);
+};
+var getPackageCircularDependencyPaths = (options) => {
+  checkBun();
+  return generatePackageCircularDependencyPaths(options.packageGraphs, options.packageOrder, options.config.logger);
+};
+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);
+};
+var watchPackages = (options) => {
+  checkBun();
+  watchPackageChanges(options.packageData, options.packageGraphs, options.config.watch, options.config.logger);
+};
+export {
+  watchPackages,
+  readPackagePalConfig,
+  readPackageData,
+  getPackageOrder,
+  getPackageGraphs,
+  getPackageCircularDependencyPaths,
+  bumpPackageVersion,
+  BumpVersionType
+};
+
+//# debugId=E0ED0EB8F615FC9B64756E2164756E21
+//# sourceMappingURL=index.js.map