@halecraft/verify 1.0.0 → 1.1.0

package/dist/index.js

@@ -1,14 +1,72 @@
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-
 // src/config.ts
 import { existsSync } from "fs";
 import { join, resolve } from "path";
 import { pathToFileURL } from "url";
+import { z } from "zod";
+var ConfigError = class extends Error {
+  constructor(message, configPath) {
+    super(message);
+    this.configPath = configPath;
+    this.name = "ConfigError";
+  }
+};
+var VerificationCommandSchema = z.object({
+  cmd: z.string(),
+  args: z.array(z.string()),
+  cwd: z.string().optional(),
+  env: z.record(z.string(), z.string()).optional(),
+  timeout: z.number().positive().optional()
+});
+var VerificationNodeSchema = z.lazy(
+  () => z.object({
+    key: z.string().min(1, "Task key cannot be empty").refine((key) => !key.includes(":"), {
+      message: "Task key cannot contain ':' (reserved for paths)"
+    }),
+    name: z.string().optional(),
+    run: z.union([z.string(), VerificationCommandSchema]).optional(),
+    children: z.array(VerificationNodeSchema).optional(),
+    strategy: z.enum(["parallel", "sequential", "fail-fast"]).optional(),
+    parser: z.string().optional(),
+    successLabel: z.string().optional(),
+    failureLabel: z.string().optional(),
+    reportingDependsOn: z.array(z.string()).optional(),
+    timeout: z.number().positive().optional()
+  })
+);
+var VerifyOptionsSchema = z.object({
+  logs: z.enum(["all", "failed", "none"]).optional(),
+  format: z.enum(["human", "json"]).optional(),
+  filter: z.array(z.string()).optional(),
+  cwd: z.string().optional(),
+  noColor: z.boolean().optional(),
+  topLevelOnly: z.boolean().optional(),
+  noTty: z.boolean().optional()
+});
+var PackageDiscoveryOptionsSchema = z.object({
+  patterns: z.array(z.string()).optional(),
+  filter: z.array(z.string()).optional(),
+  changed: z.boolean().optional()
+});
+var VerifyConfigSchema = z.object({
+  tasks: z.array(VerificationNodeSchema),
+  packages: PackageDiscoveryOptionsSchema.optional(),
+  options: VerifyOptionsSchema.optional()
+});
+function validateConfig(value, configPath) {
+  const result = VerifyConfigSchema.safeParse(value);
+  if (!result.success) {
+    const errors = result.error.issues.map((issue) => {
+      const path = issue.path.join(".");
+      return path ? `${path}: ${issue.message}` : issue.message;
+    });
+    throw new ConfigError(
+      `Invalid config:
+  - ${errors.join("\n  - ")}`,
+      configPath
+    );
+  }
+  return result.data;
+}
 function defineConfig(config) {
   return config;
 }
@@ -38,9 +96,9 @@ async function loadConfig(configPath) {
   const fileUrl = pathToFileURL(absolutePath).href;
   const module = await import(fileUrl);
   if (!module.default) {
-    throw new Error(`Config file ${configPath} must have a default export`);
+    throw new ConfigError(`Config file must have a default export`, configPath);
   }
-  return module.default;
+  return validateConfig(module.default, configPath);
 }
 async function loadConfigFromCwd(cwd, configPath) {
   if (configPath) {
@@ -65,8 +123,26 @@ function mergeOptions(configOptions, cliOptions) {
 }
 
 // src/discovery.ts
-import { existsSync as existsSync2, readdirSync, statSync } from "fs";
+import { existsSync as existsSync2, readdirSync, readFileSync, statSync } from "fs";
 import { join as join2, relative } from "path";
+
+// src/schemas/package-json.ts
+import { z as z2 } from "zod";
+var PackageJsonSchema = z2.object({
+  name: z2.string().optional(),
+  scripts: z2.record(z2.string(), z2.string()).optional()
+}).passthrough();
+function parsePackageJson(content) {
+  try {
+    const parsed = JSON.parse(content);
+    const result = PackageJsonSchema.safeParse(parsed);
+    return result.success ? result.data : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/discovery.ts
 var DEFAULT_PATTERNS = ["packages/*", "apps/*"];
 function findMatchingDirs(rootDir, patterns) {
   const results = [];
@@ -98,8 +174,9 @@ function getPackageName(packageDir) {
     return null;
   }
   try {
-    const content = __require(packageJsonPath);
-    return content.name ?? null;
+    const content = readFileSync(packageJsonPath, "utf-8");
+    const parsed = parsePackageJson(content);
+    return parsed?.name ?? null;
   } catch {
     return null;
   }
@@ -132,8 +209,133 @@ async function hasPackageChanged(_packagePath, _baseBranch = "main") {
   return true;
 }
 
+// src/filter.ts
+import leven from "leven";
+
+// src/tree.ts
+var PATH_SEPARATOR = ":";
+function buildTaskPath(parentPath, key) {
+  return parentPath ? `${parentPath}${PATH_SEPARATOR}${key}` : key;
+}
+function walkNodes(nodes, visitor, parentPath = "", depth = 0) {
+  for (const node of nodes) {
+    const path = buildTaskPath(parentPath, node.key);
+    visitor(node, path, depth);
+    if (node.children) {
+      walkNodes(node.children, visitor, path, depth + 1);
+    }
+  }
+}
+function collectPaths(nodes) {
+  const paths = [];
+  walkNodes(nodes, (_node, path) => {
+    paths.push(path);
+  });
+  return paths;
+}
+
+// src/filter.ts
+var TaskNotFoundError = class extends Error {
+  constructor(filter, suggestion, availableTasks) {
+    super(buildErrorMessage(filter, suggestion, availableTasks));
+    this.filter = filter;
+    this.suggestion = suggestion;
+    this.availableTasks = availableTasks;
+    this.name = "TaskNotFoundError";
+  }
+  exitCode = 2;
+};
+var AmbiguousTaskError = class extends Error {
+  constructor(filter, matches) {
+    super(buildAmbiguousErrorMessage(filter, matches));
+    this.filter = filter;
+    this.matches = matches;
+    this.name = "AmbiguousTaskError";
+  }
+  exitCode = 2;
+};
+function buildErrorMessage(filter, suggestion, availableTasks) {
+  let message = `Task "${filter}" not found.`;
+  if (suggestion) {
+    message += `
+
+Did you mean "${suggestion}"?`;
+  }
+  message += "\n\nAvailable tasks:";
+  for (const task of availableTasks) {
+    message += `
+  ${task}`;
+  }
+  return message;
+}
+function buildAmbiguousErrorMessage(filter, matches) {
+  let message = `Task "${filter}" is ambiguous.`;
+  message += "\n\nMatches multiple tasks:";
+  for (const match of matches) {
+    message += `
+  ${match}`;
+  }
+  return message;
+}
+function findBestSuggestion(availablePaths, invalidFilter) {
+  let bestPath;
+  let bestDistance = Number.POSITIVE_INFINITY;
+  const threshold = Math.max(2, Math.floor(invalidFilter.length / 3));
+  for (const path of availablePaths) {
+    const distance = leven(invalidFilter, path);
+    if (distance < bestDistance && distance <= threshold) {
+      bestDistance = distance;
+      bestPath = path;
+    }
+    const lastSegment = path.split(PATH_SEPARATOR).pop();
+    if (lastSegment && lastSegment !== path) {
+      const segmentDistance = leven(invalidFilter, lastSegment);
+      if (segmentDistance < bestDistance && segmentDistance <= threshold) {
+        bestDistance = segmentDistance;
+        bestPath = path;
+      }
+    }
+  }
+  return bestPath;
+}
+function resolveFilter(filter, availablePaths) {
+  if (availablePaths.includes(filter)) {
+    return { original: filter, resolved: filter, wasShortcut: false };
+  }
+  const prefixMatches = availablePaths.filter(
+    (path) => path === filter || path.startsWith(`${filter}${PATH_SEPARATOR}`)
+  );
+  if (prefixMatches.length > 0) {
+    return { original: filter, resolved: filter, wasShortcut: false };
+  }
+  const childMatches = availablePaths.filter((path) => {
+    const lastSegment = path.split(PATH_SEPARATOR).pop();
+    return lastSegment === filter;
+  });
+  if (childMatches.length === 1) {
+    return {
+      original: filter,
+      resolved: childMatches[0],
+      wasShortcut: true
+    };
+  }
+  if (childMatches.length > 1) {
+    throw new AmbiguousTaskError(filter, childMatches);
+  }
+  const suggestion = findBestSuggestion(availablePaths, filter);
+  throw new TaskNotFoundError(filter, suggestion, availablePaths);
+}
+function resolveFilters(nodes, filters) {
+  const availablePaths = collectPaths(nodes);
+  const resolved = [];
+  for (const filter of filters) {
+    resolved.push(resolveFilter(filter, availablePaths));
+  }
+  return resolved;
+}
+
 // src/init/detect.ts
-import { existsSync as existsSync3, readFileSync } from "fs";
+import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
 import { join as join3 } from "path";
 var TOOL_PATTERNS = [
   // Biome
@@ -292,8 +494,8 @@ function readPackageJson(cwd) {
     return null;
   }
   try {
-    const content = readFileSync(packageJsonPath, "utf-8");
-    return JSON.parse(content);
+    const content = readFileSync2(packageJsonPath, "utf-8");
+    return parsePackageJson(content);
   } catch {
     return null;
   }
@@ -764,6 +966,18 @@ var vitestParser = {
 };
 
 // src/parsers/index.ts
+var parsers = {
+  /** Vitest/Jest test runner output parser */
+  vitest: "vitest",
+  /** TypeScript compiler (tsc/tsgo) output parser */
+  tsc: "tsc",
+  /** Biome/ESLint linter output parser */
+  biome: "biome",
+  /** Go test runner output parser */
+  gotest: "gotest",
+  /** Generic fallback parser */
+  generic: "generic"
+};
 var ParserRegistry = class {
   parsers = /* @__PURE__ */ new Map();
   constructor() {
@@ -791,24 +1005,24 @@ var ParserRegistry = class {
   detectParser(cmd) {
     const cmdLower = cmd.toLowerCase();
     if (cmdLower.includes("vitest") || cmdLower.includes("jest")) {
-      return "vitest";
+      return parsers.vitest;
     }
     if (cmdLower.includes("tsc") || cmdLower.includes("tsgo")) {
-      return "tsc";
+      return parsers.tsc;
     }
     if (cmdLower.includes("biome") || cmdLower.includes("eslint")) {
-      return "biome";
+      return parsers.biome;
     }
     if (cmdLower.includes("go test") || cmdLower.includes("go") && cmdLower.includes("test")) {
-      return "gotest";
+      return parsers.gotest;
     }
-    return "generic";
+    return parsers.generic;
   }
   /**
    * Parse output using the specified or auto-detected parser
    */
   parse(output, exitCode, parserId, cmd) {
-    const id = parserId ?? (cmd ? this.detectParser(cmd) : "generic");
+    const id = parserId ?? (cmd ? this.detectParser(cmd) : parsers.generic);
     const parser = this.parsers.get(id) ?? genericParser;
     const result = parser.parse(output, exitCode);
     if (result) {
@@ -940,16 +1154,12 @@ var BaseReporter = class {
     return this.taskDepths.get(path) ?? 0;
   }
   /**
-   * Recursively collect task depths from verification tree
+   * Collect task depths from verification tree using walkNodes
    */
-  collectTaskDepths(nodes, parentPath, depth) {
-    for (const node of nodes) {
-      const path = parentPath ? `${parentPath}:${node.key}` : node.key;
+  collectTaskDepths(nodes) {
+    walkNodes(nodes, (_node, path, depth) => {
       this.taskDepths.set(path, depth);
-      if (node.children) {
-        this.collectTaskDepths(node.children, path, depth + 1);
-      }
-    }
+    });
   }
   /**
    * Extract summary from task result
@@ -1027,16 +1237,15 @@ var LiveDashboardReporter = class extends BaseReporter {
    * Initialize task list from verification nodes
    */
   onStart(tasks) {
-    this.collectTasks(tasks, "", 0);
+    this.collectTasks(tasks);
     this.stream.write(cursor.hide);
     this.spinner.start(() => this.redraw());
   }
   /**
-   * Recursively collect tasks from verification tree
+   * Collect tasks from verification tree using walkNodes
    */
-  collectTasks(nodes, parentPath, depth) {
-    for (const node of nodes) {
-      const path = parentPath ? `${parentPath}:${node.key}` : node.key;
+  collectTasks(nodes) {
+    walkNodes(nodes, (node, path, depth) => {
       this.tasks.set(path, {
         key: node.key,
         path,
@@ -1045,10 +1254,7 @@ var LiveDashboardReporter = class extends BaseReporter {
       });
       this.taskOrder.push(path);
       this.taskDepths.set(path, depth);
-      if (node.children) {
-        this.collectTasks(node.children, path, depth + 1);
-      }
-    }
+    });
   }
   /**
    * Get display key - shows :key for nested, key for root
@@ -1084,9 +1290,9 @@ var LiveDashboardReporter = class extends BaseReporter {
       }
       const summary = this.extractSummary(task.result);
       if (task.result.ok) {
-        return ` ${indent}${this.okMark()} verified ${this.c(ansi.bold, displayKey)} ${this.c(ansi.dim, `(${summary}, ${duration})`)}`;
+        return `${indent}${this.okMark()}   verified ${this.c(ansi.bold, displayKey)} ${this.c(ansi.dim, `(${summary}, ${duration})`)}`;
       }
-      return `${indent}${this.failMark()}    failed ${this.c(ansi.bold, displayKey)} ${this.c(ansi.dim, `(${summary}, ${duration})`)}`;
+      return `${indent}${this.failMark()}     failed ${this.c(ansi.bold, displayKey)} ${this.c(ansi.dim, `(${summary}, ${duration})`)}`;
     }
     return "";
   }
@@ -1141,7 +1347,7 @@ var SequentialReporter = class extends BaseReporter {
     this.topLevelOnly = options.topLevelOnly ?? false;
   }
   onStart(tasks) {
-    this.collectTaskDepths(tasks, "", 0);
+    this.collectTaskDepths(tasks);
   }
   /**
    * Check if task should be displayed based on topLevelOnly flag
@@ -1166,13 +1372,18 @@ var SequentialReporter = class extends BaseReporter {
       );
       return;
     }
-    const mark = result.ok ? this.okMark() : this.failMark();
-    const verb = result.ok ? "verified" : "failed";
     const summary = this.extractSummary(result);
-    this.stream.write(
-      `${mark} ${verb} ${this.c(ansi.bold, result.path)} ${this.c(ansi.dim, `(${summary}, ${duration})`)}
+    if (result.ok) {
+      this.stream.write(
+        `${this.okMark()}   verified ${this.c(ansi.bold, result.path)} ${this.c(ansi.dim, `(${summary}, ${duration})`)}
 `
-    );
+      );
+    } else {
+      this.stream.write(
+        `${this.failMark()}     failed ${this.c(ansi.bold, result.path)} ${this.c(ansi.dim, `(${summary}, ${duration})`)}
+`
+      );
+    }
   }
   onFinish() {
   }
@@ -1242,23 +1453,10 @@ function createReporter(options) {
 
 // src/runner.ts
 import { spawn } from "child_process";
+import treeKill2 from "tree-kill";
+
+// src/dependency-tracker.ts
 import treeKill from "tree-kill";
-function normalizeCommand(run) {
-  if (typeof run === "string") {
-    const parts = run.split(/\s+/);
-    return {
-      cmd: parts[0],
-      args: parts.slice(1)
-    };
-  }
-  if (Array.isArray(run)) {
-    return {
-      cmd: run[0],
-      args: run[1]
-    };
-  }
-  return run;
-}
 var ReportingDependencyTracker = class {
   /** Map of task path/key to their results */
   results = /* @__PURE__ */ new Map();
@@ -1276,26 +1474,22 @@ var ReportingDependencyTracker = class {
   processes = /* @__PURE__ */ new Map();
   /** Set of task paths that have been killed */
   killedPaths = /* @__PURE__ */ new Set();
+  /** Set of task paths that will actually run (based on filter) */
+  activePaths = /* @__PURE__ */ new Set();
   /**
    * Initialize the tracker with all tasks from the verification tree.
    * Also validates for circular dependencies and builds reverse dependency map.
    */
-  initialize(nodes, parentPath = "") {
-    for (const node of nodes) {
-      const path = parentPath ? `${parentPath}:${node.key}` : node.key;
+  initialize(nodes) {
+    walkNodes(nodes, (node, path) => {
       this.pathToKey.set(path, node.key);
       this.keyToPath.set(node.key, path);
       if (node.reportingDependsOn && node.reportingDependsOn.length > 0) {
         this.dependencies.set(path, node.reportingDependsOn);
       }
-      if (node.children) {
-        this.initialize(node.children, path);
-      }
-    }
-    if (parentPath === "") {
-      this.validateNoCycles();
-      this.buildReverseDeps();
-    }
+    });
+    this.validateNoCycles();
+    this.buildReverseDeps();
   }
   /**
    * Build reverse dependency map (task → tasks that depend on it)
@@ -1398,15 +1592,35 @@ var ReportingDependencyTracker = class {
       this.waiters.delete(key);
     }
   }
+  /**
+   * Mark a task as active (will actually run).
+   * Called before running each task to track which tasks are in the execution set.
+   */
+  markActive(path) {
+    this.activePaths.add(path);
+  }
+  /**
+   * Check if a dependency is active (will run).
+   * If not active, we shouldn't wait for it.
+   */
+  isDependencyActive(dep) {
+    const resolvedPath = this.resolveDependency(dep);
+    if (!resolvedPath) {
+      return false;
+    }
+    return this.activePaths.has(resolvedPath);
+  }
   /**
    * Wait for all dependencies of a task to complete.
+   * Only waits for dependencies that are actually active (will run).
    */
   async waitForDependencies(path) {
     const deps = this.dependencies.get(path);
     if (!deps || deps.length === 0) {
       return;
     }
-    const waitPromises = deps.map((dep) => this.waitForResult(dep));
+    const activeDeps = deps.filter((dep) => this.isDependencyActive(dep));
+    const waitPromises = activeDeps.map((dep) => this.waitForResult(dep));
     await Promise.all(waitPromises);
   }
   /**
@@ -1488,11 +1702,30 @@ var ReportingDependencyTracker = class {
     }
   }
 };
+
+// src/runner.ts
+function normalizeCommand(run, nodeTimeout) {
+  if (typeof run === "string") {
+    return {
+      cmd: run,
+      args: [],
+      shell: true,
+      timeout: nodeTimeout
+    };
+  }
+  return {
+    ...run,
+    shell: false,
+    // Command-level timeout takes precedence over node-level timeout
+    timeout: run.timeout ?? nodeTimeout
+  };
+}
 async function executeCommand(command, cwd, tracker, path) {
   const start = Date.now();
   return new Promise((resolve3) => {
+    const useShell = command.shell || process.platform === "win32";
     const proc = spawn(command.cmd, command.args, {
-      shell: process.platform === "win32",
+      shell: useShell,
       cwd: command.cwd ?? cwd,
       env: { ...process.env, NO_COLOR: "1", ...command.env }
     });
@@ -1500,6 +1733,18 @@ async function executeCommand(command, cwd, tracker, path) {
       tracker.registerProcess(path, proc);
     }
     let output = "";
+    let timedOut = false;
+    let timeoutId;
+    if (command.timeout && proc.pid) {
+      const pid = proc.pid;
+      timeoutId = setTimeout(() => {
+        timedOut = true;
+        treeKill2(pid, "SIGTERM", (err) => {
+          if (err) {
+          }
+        });
+      }, command.timeout);
+    }
     proc.stdout.on("data", (data) => {
       output += data.toString();
     });
@@ -1507,6 +1752,9 @@ async function executeCommand(command, cwd, tracker, path) {
       output += data.toString();
     });
     proc.on("close", (code, signal) => {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
       if (tracker && path) {
         tracker.unregisterProcess(path);
       }
@@ -1516,10 +1764,15 @@ async function executeCommand(command, cwd, tracker, path) {
         code: code ?? 1,
         output,
         durationMs,
-        killed
+        killed: killed && !timedOut,
+        // Don't mark as killed if it was a timeout
+        timedOut
       });
     });
     proc.on("error", (err) => {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
       if (tracker && path) {
         tracker.unregisterProcess(path);
       }
@@ -1528,14 +1781,12 @@ async function executeCommand(command, cwd, tracker, path) {
         code: 1,
         output: `Failed to execute command: ${err.message}`,
         durationMs,
-        killed: false
+        killed: false,
+        timedOut: false
       });
     });
   });
 }
-function buildPath(parentPath, key) {
-  return parentPath ? `${parentPath}:${key}` : key;
-}
 function matchesFilter(path, filters) {
   if (!filters || filters.length === 0) {
     return true;
@@ -1545,7 +1796,7 @@ function matchesFilter(path, filters) {
   });
 }
 function hasMatchingDescendant(node, parentPath, filters) {
-  const path = buildPath(parentPath, node.key);
+  const path = buildTaskPath(parentPath, node.key);
   if (matchesFilter(path, filters)) {
     return true;
   }
@@ -1625,7 +1876,8 @@ var VerificationRunner = class {
    * Run a single node (leaf or group)
    */
   async runNode(node, parentPath) {
-    const path = buildPath(parentPath, node.key);
+    const path = buildTaskPath(parentPath, node.key);
+    this.dependencyTracker.markActive(path);
     this.callbacks.onTaskStart?.(path, node.key);
     if (node.children && node.children.length > 0) {
       const start = Date.now();
@@ -1671,15 +1923,30 @@ var VerificationRunner = class {
       this.callbacks.onTaskComplete?.(result2);
       return result2;
     }
-    const command = normalizeCommand(node.run);
+    const command = normalizeCommand(node.run, node.timeout);
     const cwd = this.options.cwd ?? process.cwd();
-    const { code, output, durationMs, killed } = await executeCommand(
+    const { code, output, durationMs, killed, timedOut } = await executeCommand(
       command,
       cwd,
       this.dependencyTracker,
       path
     );
     const ok = code === 0;
+    if (timedOut) {
+      const result2 = {
+        key: node.key,
+        path,
+        ok: false,
+        code,
+        durationMs,
+        output,
+        summaryLine: `${node.key}: timed out after ${command.timeout}ms`,
+        timedOut: true
+      };
+      this.dependencyTracker.recordResult(result2);
+      this.callbacks.onTaskComplete?.(result2);
+      return result2;
+    }
     if (killed) {
       await this.dependencyTracker.waitForDependencies(path);
       const failedDep = this.dependencyTracker.getFailedDependency(path);
@@ -1698,7 +1965,7 @@ var VerificationRunner = class {
       this.callbacks.onTaskComplete?.(result2);
       return result2;
     }
-    const cmdString = `${command.cmd} ${command.args.join(" ")}`;
+    const cmdString = command.shell ? command.cmd : `${command.cmd} ${command.args.join(" ")}`;
     const parsed = this.registry.parse(
       output,
       code,
@@ -1743,6 +2010,15 @@ var VerificationRunner = class {
 // src/index.ts
 async function verify(config, cliOptions) {
   const options = mergeOptions(config.options, cliOptions);
+  if (options.filter && options.filter.length > 0) {
+    const resolved = resolveFilters(config.tasks, options.filter);
+    for (const r of resolved) {
+      if (r.wasShortcut) {
+        console.error(`\u2192 Resolving "${r.original}" to "${r.resolved}"`);
+      }
+    }
+    options.filter = resolved.map((r) => r.resolved);
+  }
   const reporter = createReporter(options);
   reporter.onStart?.(config.tasks);
   const runner = new VerificationRunner(options, void 0, {
@@ -1765,20 +2041,27 @@ async function verifyFromConfig(cwd = process.cwd(), cliOptions) {
   return verify(config, { ...cliOptions, cwd });
 }
 export {
+  AmbiguousTaskError,
+  ConfigError,
   JSONReporter,
   LiveDashboardReporter,
+  PATH_SEPARATOR,
   ParserRegistry,
   QuietReporter,
   SequentialReporter,
   SequentialReporter as TTYReporter,
+  TaskNotFoundError,
   VerificationRunner,
   biomeParser,
+  buildTaskPath,
+  collectPaths,
   createReporter,
   defaultRegistry,
   defineConfig,
   defineTask,
   detectTasks,
   discoverPackages,
+  findBestSuggestion,
   findConfigFile,
   generateConfigContent,
   genericParser,
@@ -1787,10 +2070,14 @@ export {
   loadConfig,
   loadConfigFromCwd,
   mergeOptions,
+  parsers,
+  resolveFilters,
   runInit,
   tscParser,
+  validateConfig,
   verify,
   verifyFromConfig,
-  vitestParser
+  vitestParser,
+  walkNodes
 };
 //# sourceMappingURL=index.js.map