@package-pal/core 0.0.12 → 0.0.14

package/index.js

@@ -1,12 +1,12 @@
 // @bun
 // packages/core/src/lib/types/bump-version-type.ts
 var BumpVersionType = {
-  Major: "major",
-  Minor: "minor",
   Patch: "patch",
-  Premajor: "premajor",
-  Preminor: "preminor",
+  Minor: "minor",
+  Major: "major",
   Prepatch: "prepatch",
+  Preminor: "preminor",
+  Premajor: "premajor",
   Prerelease: "prerelease"
 };
 // packages/core/src/lib/package/types/package-adapter.ts
@@ -95,6 +95,18 @@ var Config = z3.object({
     preId: z3.optional(z3.string()),
     exact: z3.optional(z3.boolean())
   })),
+  bump: z3.optional(zLooseObjectWithoutIndexSignature({
+    ignore: z3.optional(z3.union([z3.string(), z3.array(z3.string())])),
+    hooks: z3.optional(z3.object({
+      onBeforeProcessPackage: z3.optional(zLooseFunction()),
+      onProcessPackage: z3.optional(zLooseFunction()),
+      onAfterProcessPackage: z3.optional(zLooseFunction()),
+      onBeforePackagesReady: z3.optional(zLooseFunction()),
+      onPackagesReady: z3.optional(zLooseFunction()),
+      onAfterPackagesReady: z3.optional(zLooseFunction())
+    })),
+    subprocess: z3.optional(z3.object({ concurrency: z3.nullish(z3.number()) }))
+  })),
   watch: z3.optional(zLooseObjectWithoutIndexSignature({
     debounceMs: z3.optional(z3.number()),
     ignore: z3.optional(z3.union([z3.string(), z3.array(z3.string())])),
@@ -221,6 +233,18 @@ var defaultConfig = {
     preId: "",
     exact: false
   },
+  bump: {
+    ignore: "",
+    hooks: {
+      onBeforeProcessPackage: noOp2,
+      onProcessPackage: noOp2,
+      onAfterProcessPackage: noOp2,
+      onBeforePackagesReady: noOp2,
+      onPackagesReady: noOp2,
+      onAfterPackagesReady: noOp2
+    },
+    subprocess: { concurrency: null }
+  },
   watch: {
     debounceMs: 500,
     ignore: "",
@@ -388,7 +412,7 @@ import { assertDefined as assertDefined5 } from "@package-pal/util";
 
 // packages/core/src/lib/graph/functions/dfs-traverse-graph.ts
 import { assertDefined as assertDefined4 } from "@package-pal/util";
-var dfsTraverseGraph = function* (graph, traverseFromPackages) {
+var dfsTraverseGraph = function* (graph, traverseFromPackages, options) {
   const visited = new Set;
   const stack = Array.isArray(traverseFromPackages) ? traverseFromPackages.slice() : [traverseFromPackages];
   while (stack.length) {
@@ -404,6 +428,9 @@ var dfsTraverseGraph = function* (graph, traverseFromPackages) {
     yield node.packageData;
     for (const dep of node.pointsToPackages) {
       if (!visited.has(dep)) {
+        if (options?.shouldTraverse && !options.shouldTraverse(dep)) {
+          continue;
+        }
         stack.push(dep);
       }
     }
@@ -572,76 +599,25 @@ var generateTopologicalSortedGroups = (packageGraph, logger) => {
 };
 
 // packages/core/src/lib/package/functions/bump-package-version.ts
-import { styleText as styleText5 } from "util";
-import { isDefined as isDefined2 } from "@package-pal/util";
-import { inc } from "semver";
-var bumpPackageVersion = async (options) => {
-  const exact = isDefined2(options.exact) ? options.exact : options.config.version.exact;
-  const preId = isDefined2(options.preId) ? options.preId : options.config.version.preId;
-  const {
-    packageName,
-    type,
-    packageGraphs,
-    adapter,
-    config: { logger }
-  } = options;
-  logger.debug(styleText5("dim", `Bumping package '${packageName}'...`));
-  const packageNode = packageGraphs.dependencies.get(packageName);
-  if (!packageNode) {
-    throw new Error(`Package '${packageName}' not found.`);
-  }
-  const currentVersion = packageNode.packageData.version ?? "1.0.0";
-  const bumpedVersion = inc(currentVersion, type, undefined, preId);
-  if (!bumpedVersion) {
-    throw new Error(`Package '${packageName}' version '${currentVersion}' is invalid.`);
-  }
-  logger.info(`Updating '${packageName}' version: ${currentVersion} \u2192 ${bumpedVersion}.`);
-  await adapter.bumpOwnVersion(packageNode.packageData, bumpedVersion, logger);
-  const dependentWrites = [];
-  for (const dependent of dfsTraverseGraph(packageGraphs.dependents, packageName)) {
-    dependentWrites.push((async () => {
-      const updated = await adapter.bumpDependencyVersion(dependent, packageName, bumpedVersion, exact, logger);
-      if (updated) {
-        logger.debug(styleText5("dim", `Updated dependency '${packageName}' in '${dependent.name}'.`));
-      }
-    })());
-  }
-  await Promise.all(dependentWrites);
-};
-
-// packages/core/src/lib/package/functions/load-packages.ts
-import { styleText as styleText6 } from "util";
-var loadPackages = async (rootDir, packagePatterns, adapter, logger) => {
-  let resolvedPatterns = packagePatterns;
-  if (packagePatterns.length === 1 && packagePatterns[0] === "packages/*") {
-    resolvedPatterns = adapter.defaultPatterns;
-  }
-  const patternContent = resolvedPatterns.map((pattern) => `'${pattern}'`).join(", ");
-  logger.debug(styleText6("dim", `Loading packages matching pattern/s ${patternContent}...${rootDir ? ` from ${rootDir}` : ""}`));
-  const packages = [];
-  const seen = new Set;
-  for await (const packageData of adapter.scanPackages(Array.from(new Set(resolvedPatterns)), logger, rootDir)) {
-    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;
-};
-
-// packages/core/src/lib/package/functions/run-for-each-package.ts
 import { dirname as dirname4 } from "path";
+import { styleText as styleText6 } from "util";
 import {
-  assertDefined as assertDefined8,
+  isDefined as isDefined2,
+  normalisePath,
   runAsync
 } from "@package-pal/util";
+import { inc } from "semver";
+
+// packages/core/src/lib/configuration/functions/get-ignore-globs.ts
+var {Glob } = globalThis.Bun;
+var getIgnoreGlobs = (ignore) => {
+  const patterns = Array.isArray(ignore) ? ignore : [ignore];
+  const filtered = patterns.filter((pattern) => pattern.length > 0);
+  return filtered.length === 0 ? undefined : filtered.map((pattern) => new Glob(pattern));
+};
 
 // packages/core/src/lib/process/functions/run-subprocess.ts
-import { styleText as styleText7 } from "util";
+import { styleText as styleText5 } from "util";
 
 // packages/core/src/lib/process/types/exit-state.ts
 var ExitState = {
@@ -937,7 +913,7 @@ 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(styleText5("dim", `Skipped '${opts.debugName}' subprocess command; signal already cancelled.`));
     return ExitState.Cancelled;
   }
   const {
@@ -964,11 +940,11 @@ var runSubprocess = async (opts) => {
   const [readStdout, readStderr] = [{
     source: subprocess.stdout,
     type: StdType.Out,
-    writer: getLineBufferedWriter(styleText7("dim", `[O-${pid}]`.padEnd(minPrefixLen, " ")))
+    writer: getLineBufferedWriter(styleText5("dim", `[O-${pid}]`.padEnd(minPrefixLen, " ")))
   }, {
     source: subprocess.stderr,
     type: StdType.Err,
-    writer: getLineBufferedWriter(styleText7("yellow", styleText7("dim", `[E-${pid}]`.padEnd(minPrefixLen, " "))), undefined, process.stderr.write.bind(process.stderr))
+    writer: getLineBufferedWriter(styleText5("yellow", styleText5("dim", `[E-${pid}]`.padEnd(minPrefixLen, " "))), undefined, process.stderr.write.bind(process.stderr))
   }].map(async ({
     source,
     type,
@@ -987,7 +963,7 @@ var runSubprocess = async (opts) => {
     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(styleText5("dim", `Started '${opts.debugName}' subprocess command '${opts.shellCommand}' (${executedCommand}) with PID ${pid}.`));
   const [
     ,
     ,
@@ -997,21 +973,267 @@ 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(styleText5("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(styleText5("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(styleText5("dim", `Completed '${opts.debugName}' subprocess command; PID ${pid} exited.`));
       return ExitState.Completed;
     })
   ]);
   return exitState;
 };
 
+// packages/core/src/lib/package/functions/bump-package-version.ts
+var dependentWriteConcurrency = 20;
+var runBumpHookCommand = async (debugName, shellCommand, options) => {
+  if (!shellCommand) {
+    return;
+  }
+  const exitState = await runSubprocess({
+    ...options,
+    debugName,
+    shellCommand
+  });
+  if (exitState === ExitState.Errored) {
+    throw new Error(`Bump hook '${debugName}' failed.`);
+  }
+};
+var toShellCommand = (value) => {
+  return typeof value === "string" ? value : undefined;
+};
+var isIgnoredPackage = (packageData, ignoreGlobs) => {
+  const normalisedPath = normalisePath(packageData.path);
+  const normalisedDir = normalisePath(packageData.dir);
+  return ignoreGlobs.some((glob) => glob.match(normalisedPath) || glob.match(normalisedDir));
+};
+var getBumpHookProps = (bumpGroups) => {
+  return {
+    totalBumps: new Map(bumpGroups.flat().map((bump) => [bump.name, bump])),
+    totalBumpOrder: bumpGroups.map((group) => group.map((bump) => bump.name))
+  };
+};
+var runBumpPackageHooks = async (bumpConfig, bumpGroup, allBumpGroups, logger) => {
+  const {
+    totalBumps,
+    totalBumpOrder
+  } = getBumpHookProps(allBumpGroups);
+  await runAsync(bumpGroup.map((bump) => async () => {
+    const props = {
+      ...bump,
+      totalBumps,
+      totalBumpOrder
+    };
+    const cwd2 = dirname4(bump.path);
+    const env2 = {
+      PP_PACKAGE_NAME: bump.name,
+      PP_PACKAGE_DIR: bump.dir,
+      PP_PACKAGE_PATH: bump.path,
+      PP_PACKAGE_VERSION: bump.version,
+      PP_PACKAGE_PREVIOUS_VERSION: bump.previousVersion,
+      PP_PACKAGE_BUMP_TYPE: bump.type
+    };
+    await runBumpHookCommand(`before bump ${bump.name}`, toShellCommand(await bumpConfig.hooks.onBeforeProcessPackage(props)), {
+      cwd: cwd2,
+      env: env2,
+      logger
+    });
+    await runBumpHookCommand(`bump ${bump.name}`, toShellCommand(await bumpConfig.hooks.onProcessPackage(props)), {
+      cwd: cwd2,
+      env: env2,
+      logger
+    });
+    await runBumpHookCommand(`after bump ${bump.name}`, toShellCommand(await bumpConfig.hooks.onAfterProcessPackage(props)), {
+      cwd: cwd2,
+      env: env2,
+      logger
+    });
+  }), bumpConfig.subprocess.concurrency);
+};
+var runBumpReadyHooks = async (bumpConfig, bumpGroups, logger) => {
+  const {
+    totalBumps,
+    totalBumpOrder
+  } = getBumpHookProps(bumpGroups);
+  const readyProps = {
+    totalBumps,
+    totalBumpOrder
+  };
+  await runBumpHookCommand("before bump packages ready", toShellCommand(await bumpConfig.hooks.onBeforePackagesReady(readyProps)), { logger });
+  await runBumpHookCommand("bump packages ready", toShellCommand(await bumpConfig.hooks.onPackagesReady(readyProps)), { logger });
+  await runBumpHookCommand("after bump packages ready", toShellCommand(await bumpConfig.hooks.onAfterPackagesReady(readyProps)), { logger });
+};
+var createBumpPackage = (packageName, options) => ({
+  name: packageName,
+  dir: options.dir,
+  path: options.path,
+  previousVersion: options.previousVersion,
+  version: options.version,
+  type: options.type,
+  isSourcePackage: options.isSourcePackage
+});
+var bumpPackageVersion = async (options) => {
+  const exact = isDefined2(options.exact) ? options.exact : options.config.version.exact;
+  const preId = isDefined2(options.preId) ? options.preId : options.config.version.preId;
+  const {
+    packageName,
+    type,
+    cascade,
+    packageGraphs,
+    adapter,
+    config: {
+      bump,
+      logger
+    }
+  } = options;
+  logger.debug(styleText6("dim", `Bumping package '${packageName}'...`));
+  const packageNode = packageGraphs.dependencies.get(packageName);
+  if (!packageNode) {
+    throw new Error(`Package '${packageName}' not found.`);
+  }
+  const ignoreGlobs = getIgnoreGlobs(bump.ignore);
+  const ignoredPackageNames = !ignoreGlobs ? new Set : new Set(Array.from(packageGraphs.dependencies.values()).filter((node) => isIgnoredPackage(node.packageData, ignoreGlobs)).map((node) => node.packageData.name));
+  if (ignoredPackageNames.has(packageName)) {
+    throw new Error(`Package '${packageName}' matches bump.ignore and cannot be bumped.`);
+  }
+  const traversed = Array.from(dfsTraverseGraph(packageGraphs.dependents, packageName, { shouldTraverse: (name) => {
+    if (ignoredPackageNames.has(name)) {
+      logger.debug(styleText6("dim", `Ignoring bump cascade through '${name}' (matched bump.ignore).`));
+      return false;
+    }
+    return true;
+  } }));
+  const packageNamesToBump = new Set(traversed.map((pkg) => pkg.name));
+  const dependentsToBump = traversed.filter((pkg) => pkg.name !== packageName);
+  const bumpGroups = [];
+  if (cascade) {
+    const sortedGroupsObj = generateTopologicalSortedGroups(packageGraphs.dependencies, logger);
+    const packagesToProcessInOrder = sortedGroupsObj.groups.map((group) => group.filter((name) => packageNamesToBump.has(name))).filter((group) => group.length > 0);
+    const circularPackagesToProcess = sortedGroupsObj.circular.filter((name) => packageNamesToBump.has(name));
+    if (circularPackagesToProcess.length > 0) {
+      packagesToProcessInOrder.push(circularPackagesToProcess);
+    }
+    for (const packageGroup of packagesToProcessInOrder) {
+      const groupBumps = [];
+      for (const currentPackageName of packageGroup) {
+        const node = packageGraphs.dependencies.get(currentPackageName);
+        if (!node) {
+          continue;
+        }
+        const currentVersion = node.packageData.version ?? "1.0.0";
+        const bumpType = currentPackageName === packageName ? type : cascade;
+        const nextVersion = inc(currentVersion, bumpType, undefined, preId);
+        if (!nextVersion) {
+          throw new Error(`Package '${currentPackageName}' version '${currentVersion}' is invalid.`);
+        }
+        groupBumps.push(createBumpPackage(currentPackageName, {
+          dir: node.packageData.dir,
+          path: node.packageData.path,
+          previousVersion: currentVersion,
+          version: nextVersion,
+          type: bumpType,
+          isSourcePackage: currentPackageName === packageName
+        }));
+      }
+      if (groupBumps.length > 0) {
+        bumpGroups.push(groupBumps);
+      }
+    }
+    const bumpedVersionsMap = new Map;
+    for (const groupBumps of bumpGroups) {
+      const groupBumpedVersionsMap = new Map(groupBumps.map((bumpPackage) => [bumpPackage.name, bumpPackage.version]));
+      for (const [currentPackageName, nextVersion] of groupBumpedVersionsMap) {
+        bumpedVersionsMap.set(currentPackageName, nextVersion);
+      }
+      await runAsync(groupBumps.map((bumpPackage) => async () => {
+        const node = packageGraphs.dependencies.get(bumpPackage.name);
+        if (!node) {
+          return;
+        }
+        for (const depName of node.packageData.localDependencies ?? []) {
+          const newlyBumpedVersion = bumpedVersionsMap.get(depName);
+          if (newlyBumpedVersion) {
+            await adapter.bumpDependencyVersion(node.packageData, depName, newlyBumpedVersion, exact, logger);
+          }
+        }
+        logger.debug(styleText6("dim", `Bumping '${bumpPackage.name}' (${bumpPackage.type}): ${bumpPackage.previousVersion} \u2192 ${bumpPackage.version}`));
+        await adapter.bumpOwnVersion(node.packageData, bumpPackage.version, logger);
+        node.packageData.version = bumpPackage.version;
+      }), dependentWriteConcurrency);
+      await runBumpPackageHooks(bump, groupBumps, bumpGroups, logger);
+    }
+  } else {
+    const currentVersion = packageNode.packageData.version ?? "1.0.0";
+    const bumpedVersion = inc(currentVersion, type, undefined, preId);
+    if (!bumpedVersion) {
+      throw new Error(`Package '${packageName}' version '${currentVersion}' is invalid.`);
+    }
+    const sourceBump = createBumpPackage(packageName, {
+      dir: packageNode.packageData.dir,
+      path: packageNode.packageData.path,
+      previousVersion: currentVersion,
+      version: bumpedVersion,
+      type,
+      isSourcePackage: true
+    });
+    bumpGroups.push([sourceBump]);
+    logger.debug(styleText6("dim", `Bumping '${packageName}' (${type}): ${currentVersion} \u2192 ${bumpedVersion}`));
+    await adapter.bumpOwnVersion(packageNode.packageData, bumpedVersion, logger);
+    const dependentWriteTasks = [];
+    for (const dependent of dependentsToBump) {
+      dependentWriteTasks.push(async () => {
+        const updated = await adapter.bumpDependencyVersion(dependent, packageName, bumpedVersion, exact, logger);
+        if (updated) {
+          logger.debug(styleText6("dim", `Updated dependency '${packageName}' in '${dependent.name}'.`));
+        }
+      });
+    }
+    await runAsync(dependentWriteTasks, dependentWriteConcurrency);
+    await runBumpPackageHooks(bump, [sourceBump], bumpGroups, logger);
+  }
+  await runBumpReadyHooks(bump, bumpGroups, logger);
+};
+
+// packages/core/src/lib/package/functions/load-packages.ts
+import { styleText as styleText7 } from "util";
+import { normalisePath as normalisePath2 } from "@package-pal/util";
+var loadPackages = async (rootDir, packagePatterns, adapter, logger) => {
+  let resolvedPatterns = packagePatterns;
+  if (packagePatterns.length === 1 && packagePatterns[0] === "packages/*") {
+    resolvedPatterns = adapter.defaultPatterns;
+  }
+  const patternContent = resolvedPatterns.map((pattern) => `'${pattern}'`).join(", ");
+  logger.debug(styleText7("dim", `Loading packages matching pattern/s ${patternContent}...${rootDir ? ` from ${rootDir}` : ""}`));
+  const packages = [];
+  const seenByName = new Map;
+  for await (const packageData of adapter.scanPackages(Array.from(new Set(resolvedPatterns)), logger, rootDir)) {
+    const normalizedPath = normalisePath2(packageData.path);
+    const existingPath = seenByName.get(packageData.name);
+    if (existingPath === normalizedPath) {
+      continue;
+    }
+    if (existingPath) {
+      const duplicatePaths = existingPath.localeCompare(normalizedPath) <= 0 ? [existingPath, normalizedPath] : [normalizedPath, existingPath];
+      throw new Error(`Duplicate package name '${packageData.name}' found in multiple manifests: '${duplicatePaths[0]}' and '${duplicatePaths[1]}'.`);
+    }
+    seenByName.set(packageData.name, normalizedPath);
+    packages.push(packageData);
+  }
+  if (!packages.length) {
+    throw new Error(`No packages found for pattern/s ${patternContent}.`);
+  }
+  return packages.sort((a, b) => a.name.localeCompare(b.name) || normalisePath2(a.path).localeCompare(normalisePath2(b.path)));
+};
+
 // packages/core/src/lib/package/functions/run-for-each-package.ts
+import { dirname as dirname5 } from "path";
+import {
+  assertDefined as assertDefined8,
+  runAsync as runAsync2
+} from "@package-pal/util";
 var runForEachPackage = async (packageGraphs, packageOrder, getCommand, logger, topological = true, concurrency) => {
   const controller = new AbortController;
   let processPackageOrder = packageOrder.circular.length > 0 ? packageOrder.groups.concat([packageOrder.circular]) : packageOrder.groups;
@@ -1019,13 +1241,13 @@ var runForEachPackage = async (packageGraphs, packageOrder, getCommand, logger,
     processPackageOrder = [processPackageOrder.flat()];
   }
   for (const group of processPackageOrder) {
-    await runAsync(group.map((packageName) => async () => {
+    await runAsync2(group.map((packageName) => async () => {
       const packageNode = assertDefined8(packageGraphs.dependencies.get(packageName));
       const processPackageProps = {
         name: packageName,
         dir: packageNode.packageData.dir
       };
-      const processPackageCwd = dirname4(packageNode.packageData.path);
+      const processPackageCwd = dirname5(packageNode.packageData.path);
       const shellCommand = await getCommand(processPackageProps);
       if (!shellCommand) {
         return;
@@ -1054,19 +1276,18 @@ import {
   watch
 } from "fs";
 import {
-  dirname as dirname6,
+  dirname as dirname7,
   join as join3
 } from "path";
 import { styleText as styleText9 } from "util";
 import {
-  assertDefined as assertDefined12,
+  assertDefined as assertDefined11,
   getDeferredPromise,
   getStringMatcher,
   isDefined as isDefined4,
-  normalisePath,
-  runAsync as runAsync3
+  normalisePath as normalisePath3,
+  runAsync as runAsync4
 } from "@package-pal/util";
-var {Glob } = globalThis.Bun;
 
 // packages/core/src/lib/graph/functions/merge-graphs.ts
 var mergeGraphs = (a, b) => {
@@ -1101,48 +1322,40 @@ var DedupePathsBy = {
 
 // packages/core/src/lib/watch/functions/dedupe-shared-paths.ts
 import { sep } from "path";
-import { assertDefined as assertDefined9 } from "@package-pal/util";
+var isStrictDescendant = (path, candidateParent) => path.startsWith(candidateParent + sep);
 var dedupeSharedPaths = (paths, by) => {
-  const mapped = paths.map((path) => {
-    let count = 0;
-    for (const char of path) {
-      if (char === sep) {
-        count++;
-      }
-    }
-    return {
-      path,
-      count
-    };
-  });
-  mapped.sort((a, b) => a.count - b.count);
-  const sorted = mapped.map((item) => item.path);
-  const deduped = [];
+  const sortedUniquePaths = Array.from(new Set(paths)).sort((a, b) => a.localeCompare(b));
   if (by === DedupePathsBy.Parent) {
-    for (const path of sorted) {
-      if (!deduped.some((base) => path.startsWith(base + sep))) {
-        deduped.push(path);
+    const deduped2 = [];
+    let lastKept2;
+    for (const path of sortedUniquePaths) {
+      if (!lastKept2 || !isStrictDescendant(path, lastKept2)) {
+        deduped2.push(path);
+        lastKept2 = path;
       }
     }
-    return deduped;
+    return deduped2;
   }
-  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);
-      }
+  const deduped = [];
+  let lastKept;
+  for (let i = sortedUniquePaths.length - 1;i >= 0; i--) {
+    const path = sortedUniquePaths[i];
+    if (!path) {
+      continue;
     }
-    if (!deduped.some((base) => base.startsWith(path + sep))) {
+    if (!lastKept || !isStrictDescendant(lastKept, path)) {
       deduped.push(path);
+      lastKept = path;
     }
   }
-  return Array.from(new Set(deduped));
+  deduped.reverse();
+  return deduped;
 };
 
 // packages/core/src/lib/watch/functions/filter-files-modified-since.ts
 import { stat } from "fs/promises";
-import { runAsync as runAsync2 } from "@package-pal/util";
+import { runAsync as runAsync3 } from "@package-pal/util";
+var fileStatConcurrency = 20;
 var filterFilesModifiedSince = async (paths, sinceMs) => {
   const tasks = paths.map((path) => async () => {
     try {
@@ -1153,13 +1366,13 @@ var filterFilesModifiedSince = async (paths, sinceMs) => {
       return path;
     }
   });
-  const results = await runAsync2(tasks, 20);
+  const results = await runAsync3(tasks, fileStatConcurrency);
   return results.filter((path) => path !== null);
 };
 
 // packages/core/src/lib/watch/functions/get-change-logic.ts
 import { styleText as styleText8 } from "util";
-import { assertDefined as assertDefined11 } from "@package-pal/util";
+import { assertDefined as assertDefined10 } from "@package-pal/util";
 
 // packages/core/src/lib/graph/functions/generate-topological-ranking-range.ts
 import { isDefined as isDefined3 } from "@package-pal/util";
@@ -1185,11 +1398,11 @@ var generateTopologicalRankingRange = (graph, ranking) => {
 };
 
 // packages/core/src/lib/graph/functions/generate-topological-ranking.ts
-import { assertDefined as assertDefined10 } from "@package-pal/util";
+import { assertDefined as assertDefined9 } from "@package-pal/util";
 var generateTopologicalRanking = (packageProcessOrder) => {
   const rankMap = new Map;
   for (let i = 0;i < packageProcessOrder.length; i++) {
-    for (const packageName of assertDefined10(packageProcessOrder[i])) {
+    for (const packageName of assertDefined9(packageProcessOrder[i])) {
       rankMap.set(packageName, i);
     }
   }
@@ -1285,9 +1498,9 @@ var getChangeLogic = (packageGraphs, packageChanges, lastProcessedSubgraph, conf
     action = ChangeAction.Partial;
   }
   if (action === ChangeAction.Partial && isRankedGreaterThanOrEqualToPrevious) {
-    const [prevMinRank] = generateTopologicalRankingRange(assertDefined11(lastProcessedSubgraph), packageRankings);
+    const [prevMinRank] = generateTopologicalRankingRange(assertDefined10(lastProcessedSubgraph), packageRankings);
     for (let i = 0;i < changedPackageProcessOrder.length; i++) {
-      changedPackageProcessOrder[i] = assertDefined11(changedPackageProcessOrder[i]).filter((packageName) => {
+      changedPackageProcessOrder[i] = assertDefined10(changedPackageProcessOrder[i]).filter((packageName) => {
         const rank = packageRankings.get(packageName);
         return rank !== undefined && rank >= prevMinRank;
       });
@@ -1304,7 +1517,7 @@ var getChangeLogic = (packageGraphs, packageChanges, lastProcessedSubgraph, conf
 // packages/core/src/lib/watch/functions/normalise-watched-file-path.ts
 import {
   basename as basename3,
-  dirname as dirname5,
+  dirname as dirname6,
   join as join2
 } from "path";
 var removeTrailing = [
@@ -1318,7 +1531,7 @@ var removeTrailing = [
   ".swn"
 ];
 var normaliseWatchedFilePath = (filePath) => {
-  const dir = dirname5(filePath);
+  const dir = dirname6(filePath);
   let base = basename3(filePath);
   const baseLower = base.toLowerCase();
   for (const trailing of removeTrailing) {
@@ -1356,8 +1569,8 @@ var onProcessPackage = async (packageGraphs, packageChanges, watchConfig, determ
     state.lastProcessedSubgraph = state.lastProcessedSubgraph && !isRestart ? mergeGraphs(state.lastProcessedSubgraph, changedPackageSubgraph) : changedPackageSubgraph;
   }
   for (const group of changedPackageProcessOrder) {
-    await runAsync3(group.map((packageName) => async () => {
-      const packageNode = assertDefined12(packageGraphs.dependencies.get(packageName));
+    await runAsync4(group.map((packageName) => async () => {
+      const packageNode = assertDefined11(packageGraphs.dependencies.get(packageName));
       const changedPaths = packageChanges.get(packageName) ?? [];
       const processPackageProps = {
         name: packageName,
@@ -1367,13 +1580,18 @@ var onProcessPackage = async (packageGraphs, packageChanges, watchConfig, determ
         totalProcessOrder: changedPackageProcessOrder,
         signal: controller.signal
       };
-      const processPackageCwd = dirname6(packageNode.packageData.path);
+      const processPackageCwd = dirname7(packageNode.packageData.path);
+      const processPackageEnv = {
+        PP_PACKAGE_NAME: packageName,
+        PP_PACKAGE_DIR: processPackageProps.dir
+      };
       const beforeProcessPackageShellCommand = await watchConfig.hooks.onBeforeProcessPackage(processPackageProps);
       if (beforeProcessPackageShellCommand) {
         await runSubprocess({
           debugName: `before process ${packageName}`,
           shellCommand: beforeProcessPackageShellCommand,
           cwd: processPackageCwd,
+          env: processPackageEnv,
           signal: controller.signal,
           logger
         });
@@ -1394,6 +1612,7 @@ var onProcessPackage = async (packageGraphs, packageChanges, watchConfig, determ
           debugName: `process ${packageName}`,
           shellCommand: processPackageShellCommand,
           cwd: processPackageCwd,
+          env: processPackageEnv,
           signal: controller.signal,
           logger,
           onStdChunk: (chunk) => {
@@ -1419,6 +1638,7 @@ var onProcessPackage = async (packageGraphs, packageChanges, watchConfig, determ
                     debugName: `after process ${packageName}`,
                     shellCommand: processPackageErrorCommand,
                     cwd: processPackageCwd,
+                    env: processPackageEnv,
                     signal: controller.signal,
                     logger
                   });
@@ -1443,6 +1663,7 @@ var onProcessPackage = async (packageGraphs, packageChanges, watchConfig, determ
           debugName: `after process ${packageName}`,
           shellCommand: afterProcessPackageShellCommand,
           cwd: processPackageCwd,
+          env: processPackageEnv,
           signal: controller.signal,
           logger
         });
@@ -1485,14 +1706,15 @@ 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)));
+  const packageDataByPath = new Map(packageData.map((data) => [data.path, data]));
+  const dedupedRootPackageData = dedupeSharedPaths(Array.from(packageDataByPath.keys()), DedupePathsBy.Parent).map((packagePath) => assertDefined11(packageDataByPath.get(packagePath)));
   logger.debug(styleText9("dim", `Starting ${dedupedRootPackageData.length.toString()} watchers for ${packageData.length.toString()} packages.`));
   let closed = false;
   const state = { lastProcessedSubgraph: undefined };
   let debounceTimeout;
   let startedDebounceMs;
   let controller;
-  const ignoreGlobs = watchConfig.ignore ? (Array.isArray(watchConfig.ignore) ? watchConfig.ignore : [watchConfig.ignore]).map((pattern) => new Glob(pattern)) : undefined;
+  const ignoreGlobs = watchConfig.ignore ? getIgnoreGlobs(watchConfig.ignore) : undefined;
   const changedPackagePaths = new Map;
   const useController = (reset) => {
     if (controller && (reset || controller.signal.aborted)) {
@@ -1515,7 +1737,7 @@ var watchPackageChanges = (packageData, packageGraphs, watchConfig, rootDir, log
       startedDebounceMs = Date.now();
     }
     if (packageName && watchPath && filePath) {
-      const changedPath = normalisePath(join3(watchPath, normaliseWatchedFilePath(filePath)));
+      const changedPath = normalisePath3(join3(watchPath, normaliseWatchedFilePath(filePath)));
       if (ignoreGlobs?.some((glob) => glob.match(changedPath))) {
         logger.debug(styleText9("dim", `Ignoring change '${changedPath}' (matched ignore pattern).`));
         return;
@@ -1540,7 +1762,7 @@ var watchPackageChanges = (packageData, packageGraphs, watchConfig, rootDir, log
         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);
+          const processedPaths = await filterFilesModifiedSince(dedupedPaths, assertDefined11(startedDebounceMs) - fileModifiedThresholdMs);
           if (processedPaths.length) {
             packageChanges.set(packageName2, processedPaths);
           }
@@ -1558,7 +1780,7 @@ var watchPackageChanges = (packageData, packageGraphs, watchConfig, rootDir, log
     name,
     path
   }) => {
-    const watchPath = dirname6(path);
+    const watchPath = dirname7(path);
     return watch(watchPath, { recursive: true }, (event, filePath) => {
       onWatchEvent({
         watchPath,
@@ -1652,5 +1874,5 @@ export {
   BumpVersionType
 };
 
-//# debugId=C18A12C7802A030C64756E2164756E21
+//# debugId=D8A98DEC7186B6BF64756E2164756E21
 //# sourceMappingURL=index.js.map