@package-pal/core 0.0.13 → 0.0.14

package/index.d.ts

@@ -7,7 +7,11 @@ export type * from './lib/types/watch-packages-options.ts';
 export * from './lib/types/bump-version-type.ts';
 export type * from './lib/configuration/types/logger.ts';
 export type { Config, SchemaLogLevel as LogLevel, } from './lib/configuration/types/config.ts';
+export type * from './lib/configuration/types/subprocess-callback.ts';
+export type * from './lib/configuration/types/bump-package-callback-props.ts';
+export type * from './lib/configuration/types/bump-packages-ready-callback-props.ts';
 export type * from './lib/configuration/types/process-package-callback-props.ts';
+export type * from './lib/configuration/types/packages-ready-callback-props.ts';
 export type * from './lib/graph/types/package-graph.ts';
 export type * from './lib/graph/types/package-graphs.ts';
 export type * from './lib/graph/types/package-node.ts';

package/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../packages/core/src/index.ts"],"names":[],"mappings":"AAAA,mBAAmB,yCAAyC,CAAC;AAC7D,mBAAmB,0CAA0C,CAAC;AAC9D,mBAAmB,0CAA0C,CAAC;AAC9D,mBAAmB,8DAA8D,CAAC;AAClF,mBAAmB,6CAA6C,CAAC;AACjE,mBAAmB,uCAAuC,CAAC;AAC3D,cAAc,kCAAkC,CAAC;AAEjD,mBAAmB,qCAAqC,CAAC;AACzD,YAAY,EACX,MAAM,EAAE,cAAc,IAAI,QAAQ,GAClC,MAAM,qCAAqC,CAAC;AAC7C,mBAAmB,6DAA6D,CAAC;AAEjF,mBAAmB,oCAAoC,CAAC;AACxD,mBAAmB,qCAAqC,CAAC;AACzD,mBAAmB,mCAAmC,CAAC;AACvD,mBAAmB,oCAAoC,CAAC;AAExD,mBAAmB,qCAAqC,CAAC;AACzD,cAAc,wCAAwC,CAAC;AACvD,OAAO,EAAE,gBAAgB,EAAE,MAAM,+CAA+C,CAAC;AACjF,OAAO,EAAE,gBAAgB,EAAE,MAAM,6CAA6C,CAAC;AAE/E,mBAAmB,sCAAsC,CAAC;AAE1D,cAAc,cAAc,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../packages/core/src/index.ts"],"names":[],"mappings":"AAAA,mBAAmB,yCAAyC,CAAC;AAC7D,mBAAmB,0CAA0C,CAAC;AAC9D,mBAAmB,0CAA0C,CAAC;AAC9D,mBAAmB,8DAA8D,CAAC;AAClF,mBAAmB,6CAA6C,CAAC;AACjE,mBAAmB,uCAAuC,CAAC;AAC3D,cAAc,kCAAkC,CAAC;AAEjD,mBAAmB,qCAAqC,CAAC;AACzD,YAAY,EACX,MAAM,EAAE,cAAc,IAAI,QAAQ,GAClC,MAAM,qCAAqC,CAAC;AAC7C,mBAAmB,kDAAkD,CAAC;AACtE,mBAAmB,0DAA0D,CAAC;AAC9E,mBAAmB,iEAAiE,CAAC;AACrF,mBAAmB,6DAA6D,CAAC;AACjF,mBAAmB,4DAA4D,CAAC;AAEhF,mBAAmB,oCAAoC,CAAC;AACxD,mBAAmB,qCAAqC,CAAC;AACzD,mBAAmB,mCAAmC,CAAC;AACvD,mBAAmB,oCAAoC,CAAC;AAExD,mBAAmB,qCAAqC,CAAC;AACzD,cAAc,wCAAwC,CAAC;AACvD,OAAO,EAAE,gBAAgB,EAAE,MAAM,+CAA+C,CAAC;AACjF,OAAO,EAAE,gBAAgB,EAAE,MAAM,6CAA6C,CAAC;AAE/E,mBAAmB,sCAAsC,CAAC;AAE1D,cAAc,cAAc,CAAC"}

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,87 +599,25 @@ var generateTopologicalSortedGroups = (packageGraph, logger) => {
 };
 
 // packages/core/src/lib/package/functions/bump-package-version.ts
-import { styleText as styleText5 } from "util";
+import { dirname as dirname4 } from "path";
+import { styleText as styleText6 } from "util";
 import {
   isDefined as isDefined2,
+  normalisePath,
   runAsync
 } from "@package-pal/util";
 import { inc } from "semver";
-var dependentWriteConcurrency = 20;
-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 dependentWriteTasks = [];
-  for (const dependent of dfsTraverseGraph(packageGraphs.dependents, packageName)) {
-    dependentWriteTasks.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 runAsync(dependentWriteTasks, dependentWriteConcurrency);
-};
 
-// packages/core/src/lib/package/functions/load-packages.ts
-import { styleText as styleText6 } from "util";
-import { normalisePath } 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(styleText6("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 = normalisePath(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) || normalisePath(a.path).localeCompare(normalisePath(b.path)));
+// 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/package/functions/run-for-each-package.ts
-import { dirname as dirname4 } from "path";
-import {
-  assertDefined as assertDefined8,
-  runAsync as runAsync2
-} from "@package-pal/util";
-
 // 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 = {
@@ -948,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 {
@@ -975,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,
@@ -998,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 [
     ,
     ,
@@ -1008,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;
@@ -1036,7 +1247,7 @@ var runForEachPackage = async (packageGraphs, packageOrder, getCommand, logger,
         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;
@@ -1065,7 +1276,7 @@ import {
   watch
 } from "fs";
 import {
-  dirname as dirname6,
+  dirname as dirname7,
   join as join3
 } from "path";
 import { styleText as styleText9 } from "util";
@@ -1074,10 +1285,9 @@ import {
   getDeferredPromise,
   getStringMatcher,
   isDefined as isDefined4,
-  normalisePath as normalisePath2,
+  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) => {
@@ -1145,6 +1355,7 @@ var dedupeSharedPaths = (paths, by) => {
 // packages/core/src/lib/watch/functions/filter-files-modified-since.ts
 import { stat } from "fs/promises";
 import { runAsync as runAsync3 } from "@package-pal/util";
+var fileStatConcurrency = 20;
 var filterFilesModifiedSince = async (paths, sinceMs) => {
   const tasks = paths.map((path) => async () => {
     try {
@@ -1155,7 +1366,7 @@ var filterFilesModifiedSince = async (paths, sinceMs) => {
       return path;
     }
   });
-  const results = await runAsync3(tasks, 20);
+  const results = await runAsync3(tasks, fileStatConcurrency);
   return results.filter((path) => path !== null);
 };
 
@@ -1306,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 = [
@@ -1320,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) {
@@ -1369,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
         });
@@ -1396,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) => {
@@ -1421,6 +1638,7 @@ var onProcessPackage = async (packageGraphs, packageChanges, watchConfig, determ
                     debugName: `after process ${packageName}`,
                     shellCommand: processPackageErrorCommand,
                     cwd: processPackageCwd,
+                    env: processPackageEnv,
                     signal: controller.signal,
                     logger
                   });
@@ -1445,6 +1663,7 @@ var onProcessPackage = async (packageGraphs, packageChanges, watchConfig, determ
           debugName: `after process ${packageName}`,
           shellCommand: afterProcessPackageShellCommand,
           cwd: processPackageCwd,
+          env: processPackageEnv,
           signal: controller.signal,
           logger
         });
@@ -1495,7 +1714,7 @@ var watchPackageChanges = (packageData, packageGraphs, watchConfig, rootDir, log
   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)) {
@@ -1518,7 +1737,7 @@ var watchPackageChanges = (packageData, packageGraphs, watchConfig, rootDir, log
       startedDebounceMs = Date.now();
     }
     if (packageName && watchPath && filePath) {
-      const changedPath = normalisePath2(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;
@@ -1561,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,
@@ -1655,5 +1874,5 @@ export {
   BumpVersionType
 };
 
-//# debugId=9A67423F575E08A064756E2164756E21
+//# debugId=D8A98DEC7186B6BF64756E2164756E21
 //# sourceMappingURL=index.js.map