@visulima/task-runner 1.0.0-alpha.3 → 1.0.0-alpha.5

package/dist/packem_shared/{filterAffectedTasks-I-18zPg6.js → buildForwardDependencyMap-0BJFMMPv.js}

@@ -22,8 +22,10 @@ const {
 } = __cjs_getBuiltinModule("node:child_process");
 
 const validateGitRef = (ref) => {
-  if (!/^[a-zA-Z0-9._\-/~^@{}]+$/.test(ref)) {
-    throw new Error(`Invalid git ref: "${ref}". Only alphanumeric characters, dots, dashes, underscores, slashes, tildes, carets, and @ are allowed.`);
+  if (!/^[\w./~^@{}][\w.\-/~^@{}]*$/.test(ref)) {
+    throw new Error(
+      `Invalid git ref: "${ref}". Refs must start with an alphanumeric character or one of _ . / ~ ^ @ { } and may only contain letters, digits, dots, dashes, underscores, slashes, tildes, carets, @, and braces.`
+    );
   }
 };
 const findProjectForFile = (filePath, projects) => {
@@ -38,34 +40,69 @@ const findProjectForFile = (filePath, projects) => {
   }
   return bestMatch;
 };
-const expandAffected = (affectedProjects, projectGraph) => {
-  const reverseDependencies = /* @__PURE__ */ new Map();
+const buildReverseDependencyMap = (projectGraph) => {
+  const map = /* @__PURE__ */ new Map();
   for (const [project, dependencies] of Object.entries(projectGraph.dependencies)) {
     for (const dependency of dependencies) {
-      let set = reverseDependencies.get(dependency.target);
+      let set = map.get(dependency.target);
       if (!set) {
         set = /* @__PURE__ */ new Set();
-        reverseDependencies.set(dependency.target, set);
+        map.set(dependency.target, set);
       }
       set.add(project);
     }
   }
-  const queue = [...affectedProjects];
+  return map;
+};
+const buildForwardDependencyMap = (projectGraph) => {
+  const map = /* @__PURE__ */ new Map();
+  for (const [project, dependencies] of Object.entries(projectGraph.dependencies)) {
+    const set = /* @__PURE__ */ new Set();
+    for (const dependency of dependencies) {
+      set.add(dependency.target);
+    }
+    if (set.size > 0) {
+      map.set(project, set);
+    }
+  }
+  return map;
+};
+const expandInDirection = (affected, seeds, adjacency, scope) => {
+  const added = /* @__PURE__ */ new Set();
+  const visited = new Set(seeds);
+  const queue = [...seeds];
   while (queue.length > 0) {
     const project = queue.shift();
-    if (project === void 0) {
+    const neighbors = adjacency.get(project);
+    if (!neighbors) {
       continue;
     }
-    const dependents = reverseDependencies.get(project);
-    if (dependents) {
-      for (const dependent of dependents) {
-        if (!affectedProjects.has(dependent)) {
-          affectedProjects.add(dependent);
-          queue.push(dependent);
+    for (const neighbor of neighbors) {
+      if (!visited.has(neighbor)) {
+        visited.add(neighbor);
+        affected.add(neighbor);
+        added.add(neighbor);
+        if (scope === "deep") {
+          queue.push(neighbor);
         }
       }
     }
   }
+  return added;
+};
+const expandAffected = (changedProjects, projectGraph, options) => {
+  const affected = new Set(changedProjects);
+  let downstream = /* @__PURE__ */ new Set();
+  let upstream = /* @__PURE__ */ new Set();
+  if (options.downstream !== "none") {
+    const reverseDeps = buildReverseDependencyMap(projectGraph);
+    downstream = expandInDirection(affected, changedProjects, reverseDeps, options.downstream);
+  }
+  if (options.upstream !== "none") {
+    const forwardDeps = buildForwardDependencyMap(projectGraph);
+    upstream = expandInDirection(affected, changedProjects, forwardDeps, options.upstream);
+  }
+  return { affected, downstream, upstream };
 };
 const getMergeBase = (workspaceRoot, base, head) => new Promise((resolve, reject) => {
   execFile("git", ["merge-base", base, head], { cwd: workspaceRoot }, (error, stdout) => {
@@ -103,7 +140,7 @@ const getChangedFiles = async (workspaceRoot, base, head) => {
   }
 };
 const getAffectedProjects = async (options) => {
-  const { base = "main", head = "HEAD", projectGraph, projects, workspaceRoot } = options;
+  const { base = "main", downstream = "deep", head = "HEAD", projectGraph, projects, upstream = "none", workspaceRoot } = options;
   const changedFiles = await getChangedFiles(workspaceRoot, base, head);
   const changedProjects = /* @__PURE__ */ new Set();
   for (const file of changedFiles) {
@@ -114,16 +151,19 @@ const getAffectedProjects = async (options) => {
       return {
         affectedProjects: Object.keys(projects),
         changedFiles,
-        changedProjects: Object.keys(projects)
+        changedProjects: [...changedProjects],
+        downstreamProjects: [],
+        upstreamProjects: []
       };
     }
   }
-  const affectedProjects = new Set(changedProjects);
-  expandAffected(affectedProjects, projectGraph);
+  const result = expandAffected(changedProjects, projectGraph, { downstream, upstream });
   return {
-    affectedProjects: [...affectedProjects],
+    affectedProjects: [...result.affected],
     changedFiles,
-    changedProjects: [...changedProjects]
+    changedProjects: [...changedProjects],
+    downstreamProjects: [...result.downstream],
+    upstreamProjects: [...result.upstream]
   };
 };
 const filterAffectedTasks = (taskIds, affectedProjects) => taskIds.filter((taskId) => {
@@ -132,4 +172,4 @@ const filterAffectedTasks = (taskIds, affectedProjects) => taskIds.filter((taskI
   return affectedProjects.has(project);
 });
 
-export { filterAffectedTasks, getAffectedProjects, getChangedFiles };
+export { buildForwardDependencyMap, buildReverseDependencyMap, expandAffected, filterAffectedTasks, getAffectedProjects, getChangedFiles };

package/dist/packem_shared/{computeTaskHash-BoCnnvIJ.js → computeTaskHash-B2SVZqgp.js}

@@ -27,7 +27,7 @@ import { b as hashStrings, s as sortObjectKeys, c as collectFiles, x as xxh3Hash
 import { join, resolve, relative } from '@visulima/path';
 import { getFrameworkEnvVariables } from './detectFrameworks-CeFzKE6J.js';
 import { LockfileHasher } from './extractPackageName-CbVNW-dr.js';
-import { loadNativeBindings } from './isNativeAvailable-BWhnZ4ES.js';
+import { loadNativeBindings } from './isNativeAvailable-BpD28A6Z.js';
 
 const DEFAULT_GLOBAL_INPUTS = ["package-lock.json", "pnpm-lock.yaml", "yarn.lock", "tsconfig.base.json", "tsconfig.json", ".env"];
 const IGNORED_DIRS = /* @__PURE__ */ new Set([".git", "coverage", "dist", "node_modules"]);
@@ -104,7 +104,6 @@ class InProcessTaskHasher {
     this.#lockfileHasher = this.#smartLockfileHashing ? new LockfileHasher(options.workspaceRoot) : void 0;
     this.#frameworkInference = options.frameworkInference ?? false;
   }
-  // eslint-disable-next-line sonarjs/cognitive-complexity
   async hashTask(task) {
     const commandHash = this.#hashCommand(task);
     const nodes = {};

package/dist/packem_shared/createInputHandler-DTfePcTG.js

@@ -0,0 +1,37 @@
+const INPUT_PREFIX_REGEX = /^(\S+?):(.+)/s;
+const createInputHandler = (commands, options = {}) => {
+  const { defaultTarget = 0, inputStream = process.stdin, pauseOnFinish = true } = options;
+  const byIndex = /* @__PURE__ */ new Map();
+  const byName = /* @__PURE__ */ new Map();
+  for (const cmd of commands) {
+    byIndex.set(cmd.index, cmd);
+    if (cmd.name) {
+      byName.set(cmd.name, cmd);
+    }
+  }
+  const onData = (data) => {
+    const input = data.toString();
+    const match = INPUT_PREFIX_REGEX.exec(input);
+    if (match) {
+      const [, target, rest] = match;
+      const targetCmd = byName.get(target) ?? byIndex.get(Number(target));
+      if (targetCmd) {
+        targetCmd.stdin.write(rest);
+        return;
+      }
+    }
+    const defaultCmd = byIndex.get(defaultTarget);
+    if (defaultCmd) {
+      defaultCmd.stdin.write(input);
+    }
+  };
+  inputStream.on("data", onData);
+  return () => {
+    inputStream.removeListener("data", onData);
+    if (pauseOnFinish && typeof inputStream.pause === "function") {
+      inputStream.pause();
+    }
+  };
+};
+
+export { createInputHandler };

package/dist/packem_shared/{defaultTaskRunner-CrW4v5Ye.js → defaultTaskRunner-BdFTifsh.js}

@@ -1,10 +1,9 @@
-import { Cache } from './Cache-IYpTYVUC.js';
+import { Cache } from './Cache-iAjRMV2d.js';
 import { inferFrameworkEnvPatterns } from './detectFrameworks-CeFzKE6J.js';
-import { EmptyLifeCycle } from './CompositeLifeCycle-7AtYw1dv.js';
-import { RemoteCache } from './RemoteCache-BDqrnDEi.js';
-import { InProcessTaskHasher } from './computeTaskHash-BoCnnvIJ.js';
-import { TaskOrchestrator } from './TaskOrchestrator-BvYs3ONw.js';
-import { TaskScheduler } from './TaskScheduler-CJilHDta.js';
+import { RemoteCache } from './RemoteCache-BFceSe4a.js';
+import { InProcessTaskHasher } from './computeTaskHash-B2SVZqgp.js';
+import { TaskOrchestrator } from './TaskOrchestrator-lLn-PH1m.js';
+import { TaskScheduler } from './parsePartition-C4-P5RjK.js';
 
 const resolveParallel = (parallel) => {
   if (typeof parallel === "number") {
@@ -16,7 +15,7 @@ const resolveParallel = (parallel) => {
   return 3;
 };
 const defaultTaskRunner = async (_tasks, options, context) => {
-  const { lifeCycle = new EmptyLifeCycle(), projectGraph, taskExecutor, taskGraph, workspaceRoot } = context;
+  const { lifeCycle, projectGraph, taskExecutor, taskGraph, workspaceRoot } = context;
   const cache = new Cache({
     cacheDirectory: options.cacheDirectory,
     maxCacheAge: options.maxCacheAge,

package/dist/packem_shared/detectScriptShell-CR-xXKA4.js

@@ -0,0 +1,53 @@
+import { createRequire as __cjs_createRequire } from "node:module";
+
+const __cjs_require = __cjs_createRequire(import.meta.url);
+
+const __cjs_getProcess = typeof globalThis !== "undefined" && typeof globalThis.process !== "undefined" ? globalThis.process : process;
+
+const __cjs_getBuiltinModule = (module) => {
+    // Check if we're in Node.js and version supports getBuiltinModule
+    if (typeof __cjs_getProcess !== "undefined" && __cjs_getProcess.versions && __cjs_getProcess.versions.node) {
+        const [major, minor] = __cjs_getProcess.versions.node.split(".").map(Number);
+        // Node.js 20.16.0+ and 22.3.0+
+        if (major > 22 || (major === 22 && minor >= 3) || (major === 20 && minor >= 16)) {
+            return __cjs_getProcess.getBuiltinModule(module);
+        }
+    }
+    // Fallback to createRequire
+    return __cjs_require(module);
+};
+
+const {
+  execFileSync
+} = __cjs_getBuiltinModule("node:child_process");
+
+let cachedShellPath;
+const detectScriptShell = () => {
+  if (cachedShellPath !== void 0) {
+    return cachedShellPath ?? void 0;
+  }
+  const envShell = process.env["npm_config_script_shell"];
+  if (envShell) {
+    cachedShellPath = envShell;
+    return envShell;
+  }
+  try {
+    const result = execFileSync("npm", ["config", "get", "script-shell"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 5e3
+    }).trim();
+    if (result && result !== "undefined" && result !== "") {
+      cachedShellPath = result;
+      return result;
+    }
+  } catch {
+  }
+  cachedShellPath = null;
+  return void 0;
+};
+const resetShellCache = () => {
+  cachedShellPath = void 0;
+};
+
+export { detectScriptShell, resetShellCache };

package/dist/packem_shared/enforceProjectConstraints-C5Jp_C3u.js

@@ -0,0 +1,111 @@
+const LAYER_ORDER = ["configuration", "library", "scaffolding", "tool", "automation", "application"];
+const layerIndex = (layer) => {
+  if (!layer) {
+    return void 0;
+  }
+  const idx = LAYER_ORDER.indexOf(layer);
+  return idx === -1 ? void 0 : idx;
+};
+const enforceProjectConstraints = (projectGraph, constraints) => {
+  const violations = [];
+  const { dependencyKindRules, enforceLayerRelationships, tagRelationships, typeBoundaries } = constraints;
+  const hasTagRules = tagRelationships && Object.keys(tagRelationships).length > 0;
+  const hasTypeBoundaries = typeBoundaries !== void 0;
+  const hasKindRules = dependencyKindRules !== void 0;
+  const hasLayerRules = enforceLayerRelationships === true;
+  if (!hasTagRules && !hasTypeBoundaries && !hasKindRules && !hasLayerRules) {
+    return violations;
+  }
+  const enforceAppBoundary = typeBoundaries?.enforceApplicationBoundary !== false;
+  const allowedDepTypes = typeBoundaries?.allowedDependencyTypes;
+  for (const [projectName, dependencies] of Object.entries(projectGraph.dependencies)) {
+    const sourceNode = projectGraph.nodes[projectName];
+    if (!sourceNode) {
+      continue;
+    }
+    const sourceTags = sourceNode.data.tags ?? [];
+    const sourceType = sourceNode.type;
+    for (const dep of dependencies) {
+      const depNode = projectGraph.nodes[dep.target];
+      if (!depNode) {
+        continue;
+      }
+      const depTags = depNode.data.tags ?? [];
+      const depType = depNode.type;
+      let appBoundaryViolated = false;
+      if (hasTypeBoundaries && enforceAppBoundary && depType === "application") {
+        appBoundaryViolated = true;
+        violations.push({
+          dependencyProject: dep.target,
+          message: `Project "${projectName}" depends on "${dep.target}", which is an application. Applications should not be depended upon by other projects.`,
+          rule: "type-boundary",
+          sourceProject: projectName
+        });
+      }
+      if (allowedDepTypes && !appBoundaryViolated) {
+        const allowed = allowedDepTypes[sourceType];
+        if (allowed && !allowed.includes(depType)) {
+          violations.push({
+            dependencyProject: dep.target,
+            message: `Project "${projectName}" (type: ${sourceType}) depends on "${dep.target}" (type: ${depType}). Allowed dependency types for "${sourceType}" are: ${allowed.join(", ")}.`,
+            rule: "type-boundary",
+            sourceProject: projectName
+          });
+        }
+      }
+      if (hasTagRules && tagRelationships) {
+        for (const sourceTag of sourceTags) {
+          const requiredTags = tagRelationships[sourceTag];
+          if (!requiredTags || requiredTags.length === 0) {
+            continue;
+          }
+          const hasRequiredTag = depTags.some((tag) => requiredTags.includes(tag));
+          if (!hasRequiredTag) {
+            violations.push({
+              dependencyProject: dep.target,
+              message: `Project "${projectName}" (tag: ${sourceTag}) depends on "${dep.target}", which doesn't have any of the required tags: ${requiredTags.join(", ")}. ${depTags.length > 0 ? `"${dep.target}" has tags: ${depTags.join(", ")}.` : `"${dep.target}" has no tags.`}`,
+              rule: "tag-relationship",
+              sourceProject: projectName
+            });
+          }
+        }
+      }
+      if (hasKindRules && dependencyKindRules) {
+        if (dependencyKindRules.noProductionDependencyOnApplication && dep.type === "static" && depType === "application") {
+          violations.push({
+            dependencyProject: dep.target,
+            message: `Project "${projectName}" has a production dependency on "${dep.target}", which is an application. Production dependencies on applications are not allowed. Use devDependencies instead if needed for testing.`,
+            rule: "dependency-kind",
+            sourceProject: projectName
+          });
+        }
+        if (dependencyKindRules.noDevDependencyOnProductionDep && dep.type === "devDependency" && sourceType === "library") {
+          const hasProductionDep = dependencies.some((other) => other.target === dep.target && other.type === "static");
+          if (hasProductionDep) {
+            violations.push({
+              dependencyProject: dep.target,
+              message: `Project "${projectName}" has "${dep.target}" in both dependencies and devDependencies. This is redundant — remove it from devDependencies.`,
+              rule: "dependency-kind",
+              sourceProject: projectName
+            });
+          }
+        }
+      }
+      if (hasLayerRules) {
+        const sourceLayer = layerIndex(sourceNode.data.layer);
+        const depLayer = layerIndex(depNode.data.layer);
+        if (sourceLayer !== void 0 && depLayer !== void 0 && depLayer > sourceLayer) {
+          violations.push({
+            dependencyProject: dep.target,
+            message: `Project "${projectName}" (layer: ${sourceNode.data.layer}) depends on "${dep.target}" (layer: ${depNode.data.layer}). A "${sourceNode.data.layer}" project may only depend on projects at the same or lower layer. Hierarchy: ${LAYER_ORDER.join(" < ")}.`,
+            rule: "layer-relationship",
+            sourceProject: projectName
+          });
+        }
+      }
+    }
+  }
+  return violations;
+};
+
+export { enforceProjectConstraints };

package/dist/packem_shared/expandArguments-0AwD2BIA.js

@@ -0,0 +1,26 @@
+const PLACEHOLDER_REGEX = /\\?\{([@*]|[1-9]\d*)\}/g;
+const shellQuote = (s) => `'${s.replaceAll("'", String.raw`'\''`)}'`;
+const expandArguments = (config, additionalArguments) => {
+  if (additionalArguments.length === 0) {
+    return config;
+  }
+  const command = config.command.replaceAll(PLACEHOLDER_REGEX, (match, target) => {
+    if (match.startsWith("\\")) {
+      return match.slice(1);
+    }
+    const index = Number(target);
+    if (!Number.isNaN(index) && index <= additionalArguments.length) {
+      return shellQuote(additionalArguments[index - 1]);
+    }
+    if (target === "@") {
+      return additionalArguments.map(shellQuote).join(" ");
+    }
+    if (target === "*") {
+      return shellQuote(additionalArguments.join(" "));
+    }
+    return "";
+  });
+  return { ...config, command };
+};
+
+export { expandArguments };

package/dist/packem_shared/expandShortcut-BVG05ee4.js

@@ -0,0 +1,23 @@
+const SHORTCUT_REGEX = /^(npm|yarn|pnpm|bun|node|deno):(\S+)(.*)/;
+const expandShortcut = (config) => {
+  const match = SHORTCUT_REGEX.exec(config.command);
+  if (!match) {
+    return config;
+  }
+  const [, prefix, script, args] = match;
+  let runPrefix;
+  if (prefix === "node") {
+    runPrefix = "node --run";
+  } else if (prefix === "deno") {
+    runPrefix = "deno task";
+  } else {
+    runPrefix = `${prefix} run`;
+  }
+  return {
+    ...config,
+    command: `${runPrefix} ${script}${args}`,
+    name: config.name ?? script
+  };
+};
+
+export { expandShortcut };

package/dist/packem_shared/expandWildcard-B0xN_knq.js

@@ -0,0 +1,107 @@
+import { createRequire as __cjs_createRequire } from "node:module";
+
+const __cjs_require = __cjs_createRequire(import.meta.url);
+
+const __cjs_getProcess = typeof globalThis !== "undefined" && typeof globalThis.process !== "undefined" ? globalThis.process : process;
+
+const __cjs_getBuiltinModule = (module) => {
+    // Check if we're in Node.js and version supports getBuiltinModule
+    if (typeof __cjs_getProcess !== "undefined" && __cjs_getProcess.versions && __cjs_getProcess.versions.node) {
+        const [major, minor] = __cjs_getProcess.versions.node.split(".").map(Number);
+        // Node.js 20.16.0+ and 22.3.0+
+        if (major > 22 || (major === 22 && minor >= 3) || (major === 20 && minor >= 16)) {
+            return __cjs_getProcess.getBuiltinModule(module);
+        }
+    }
+    // Fallback to createRequire
+    return __cjs_require(module);
+};
+
+const {
+  existsSync,
+  readFileSync
+} = __cjs_getBuiltinModule("node:fs");
+const {
+  join
+} = __cjs_getBuiltinModule("node:path");
+
+const RUN_COMMAND_REGEX = /(?:npm|yarn|pnpm|bun) run|node --run|deno task/;
+const readPackageScripts = (cwd) => {
+  try {
+    const raw = readFileSync(join(cwd, "package.json"), "utf8");
+    const pkg = JSON.parse(raw);
+    return pkg.scripts ?? {};
+  } catch {
+    return {};
+  }
+};
+const readDenoTasks = (cwd) => {
+  const tasks = {};
+  for (const filename of ["deno.json", "deno.jsonc"]) {
+    const filepath = join(cwd, filename);
+    if (existsSync(filepath)) {
+      try {
+        let raw = readFileSync(filepath, "utf8");
+        if (filename.endsWith("c")) {
+          raw = raw.replaceAll(/"(?:[^"\\]|\\.)*"|\/\/[^\n]*/g, (match) => match.startsWith('"') ? match : "");
+        }
+        const config = JSON.parse(raw);
+        if (config.tasks) {
+          Object.assign(tasks, config.tasks);
+        }
+      } catch {
+      }
+      break;
+    }
+  }
+  const pkgScripts = readPackageScripts(cwd);
+  return { ...pkgScripts, ...tasks };
+};
+const escapeRegExp = (s) => s.replaceAll(/[$()*+.?[\\\]^{|}]/g, String.raw`\$&`);
+const expandWildcard = (config) => {
+  const { command } = config;
+  const runMatch = RUN_COMMAND_REGEX.exec(command);
+  if (!runMatch) {
+    return config;
+  }
+  const afterRun = command.slice(runMatch.index + runMatch[0].length).trim();
+  const scriptPattern = afterRun.split(/\s/)[0] ?? "";
+  if (!scriptPattern.includes("*")) {
+    return config;
+  }
+  const cwd = config.cwd ?? process.cwd();
+  const isDeno = runMatch[0] === "deno task";
+  const scripts = isDeno ? readDenoTasks(cwd) : readPackageScripts(cwd);
+  const scriptNames = Object.keys(scripts);
+  const parts = scriptPattern.split("*");
+  const regexString = parts.map(escapeRegExp).join("(.+)");
+  const wildcardRegex = new RegExp(`^${regexString}$`);
+  const omitMatch = /!\(([^)]+)\)/.exec(scriptPattern);
+  let omitRegex;
+  if (omitMatch) {
+    omitRegex = new RegExp(omitMatch[1]);
+  }
+  const matching = scriptNames.filter((name) => {
+    if (!wildcardRegex.test(name)) {
+      return false;
+    }
+    if (omitRegex?.test(name)) {
+      return false;
+    }
+    return true;
+  });
+  if (matching.length === 0) {
+    return config;
+  }
+  const remainingArgs = afterRun.slice(scriptPattern.length);
+  const runPrefix = command.slice(0, runMatch.index + runMatch[0].length);
+  return matching.map((scriptName) => {
+    return {
+      ...config,
+      command: `${runPrefix} ${scriptName}${remainingArgs}`,
+      name: config.name ?? scriptName
+    };
+  });
+};
+
+export { expandWildcard };

package/dist/packem_shared/{findCycle-DF4_BRdO.js → findCycle-DefgNYhg.js}

@@ -8,7 +8,7 @@ const findCycle = (taskGraph) => {
     }
     const stack = [taskId];
     while (stack.length > 0) {
-      const current = stack[stack.length - 1];
+      const current = stack.at(-1);
       if (!visited.has(current)) {
         visited.add(current);
         inStack.add(current);

package/dist/packem_shared/formatTimingTable-3qtCM552.js

@@ -0,0 +1,46 @@
+const formatDuration = (ms) => {
+  if (ms < 1e3) {
+    return `${Math.round(ms)}ms`;
+  }
+  if (ms < 6e4) {
+    return `${(ms / 1e3).toFixed(1)}s`;
+  }
+  const minutes = Math.floor(ms / 6e4);
+  const seconds = (ms % 6e4 / 1e3).toFixed(1);
+  return `${minutes}m ${seconds}s`;
+};
+const formatTimingTable = (closeEvents) => {
+  if (closeEvents.length === 0) {
+    return "";
+  }
+  const sorted = closeEvents.toSorted((a, b) => b.durationMs - a.durationMs);
+  const nameWidth = Math.max(4, ...sorted.map((e) => (e.name ?? String(e.index)).length));
+  const durationWidth = Math.max(8, ...sorted.map((e) => formatDuration(e.durationMs).length));
+  const codeWidth = Math.max(4, ...sorted.map((e) => String(e.exitCode).length));
+  const header = ["name".padEnd(nameWidth), "duration".padEnd(durationWidth), "code".padEnd(codeWidth), "killed", "command"].join(" │ ");
+  const separator = ["─".repeat(nameWidth), "─".repeat(durationWidth), "─".repeat(codeWidth), "─".repeat(6), "─".repeat(20)].join(
+    "─┼─"
+  );
+  const rows = sorted.map((event) => {
+    const name = (event.name ?? String(event.index)).padEnd(nameWidth);
+    const duration = formatDuration(event.durationMs).padEnd(durationWidth);
+    const code = String(event.exitCode).padEnd(codeWidth);
+    const killed = (event.killed ? "yes" : "no").padEnd(6);
+    const command = event.command.length > 40 ? `${event.command.slice(0, 39)}…` : event.command;
+    return [name, duration, code, killed, command].join(" │ ");
+  });
+  return [header, separator, ...rows].join("\n");
+};
+const logTimings = (closeEvents, output = process.stdout) => {
+  if (closeEvents.length === 0) {
+    return;
+  }
+  const table = formatTimingTable(closeEvents);
+  output.write(
+    "\n── Timing Summary ───────────────────────────────────\n\n"
+  );
+  output.write(table);
+  output.write("\n\n");
+};
+
+export { formatTimingTable, logTimings };

package/dist/packem_shared/isNativeAvailable-BpD28A6Z.js

@@ -0,0 +1,44 @@
+import { createRequire as __cjs_createRequire } from "node:module";
+
+const __cjs_require = __cjs_createRequire(import.meta.url);
+
+const __cjs_getProcess = typeof globalThis !== "undefined" && typeof globalThis.process !== "undefined" ? globalThis.process : process;
+
+const __cjs_getBuiltinModule = (module) => {
+    // Check if we're in Node.js and version supports getBuiltinModule
+    if (typeof __cjs_getProcess !== "undefined" && __cjs_getProcess.versions && __cjs_getProcess.versions.node) {
+        const [major, minor] = __cjs_getProcess.versions.node.split(".").map(Number);
+        // Node.js 20.16.0+ and 22.3.0+
+        if (major > 22 || (major === 22 && minor >= 3) || (major === 20 && minor >= 16)) {
+            return __cjs_getProcess.getBuiltinModule(module);
+        }
+    }
+    // Fallback to createRequire
+    return __cjs_require(module);
+};
+
+const {
+  createRequire
+} = __cjs_getBuiltinModule("node:module");
+
+let nativeBindings;
+let loadAttempted = false;
+const esmRequire = createRequire(import.meta.url);
+const loadNativeBindings = () => {
+  if (loadAttempted) {
+    return nativeBindings;
+  }
+  loadAttempted = true;
+  try {
+    const loaded = esmRequire("../index.js");
+    if (typeof loaded.hashCommand === "function" && typeof loaded.hashFile === "function" && typeof loaded.runConcurrent === "function") {
+      nativeBindings = loaded;
+    }
+  } catch {
+    nativeBindings = void 0;
+  }
+  return nativeBindings;
+};
+const isNativeAvailable = () => loadNativeBindings() !== void 0;
+
+export { isNativeAvailable, loadNativeBindings };

package/dist/packem_shared/parseCommands-D-IgF8Zh.js

@@ -0,0 +1,26 @@
+import { expandArguments } from './expandArguments-0AwD2BIA.js';
+import { expandShortcut } from './expandShortcut-BVG05ee4.js';
+import { expandWildcard } from './expandWildcard-B0xN_knq.js';
+import { stripQuotes } from './stripQuotes-Cey-zwFf.js';
+
+const parseCommands = (inputs, options = {}) => {
+  const { additionalArguments = [] } = options;
+  let configs = inputs.map((input) => {
+    if (typeof input === "string") {
+      return { command: input };
+    }
+    return { ...input };
+  });
+  configs = configs.map(stripQuotes);
+  configs = configs.map(expandShortcut);
+  configs = configs.flatMap((config) => {
+    const result = expandWildcard(config);
+    return Array.isArray(result) ? result : [result];
+  });
+  if (additionalArguments.length > 0) {
+    configs = configs.map((config) => expandArguments(config, additionalArguments));
+  }
+  return configs;
+};
+
+export { expandArguments, expandShortcut, expandWildcard, parseCommands, stripQuotes };