@vzn/vx 0.0.34 → 0.0.35

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vzn/vx",
-  "version": "0.0.34",
+  "version": "0.0.35",
   "description": "An open, extensible monorepo task runner.",
   "type": "module",
   "exports": {
@@ -17,10 +17,10 @@
     "node": ">=18"
   },
   "optionalDependencies": {
-    "@vzn/vx-linux-x64": "0.0.34",
-    "@vzn/vx-linux-arm64": "0.0.34",
-    "@vzn/vx-darwin-x64": "0.0.34",
-    "@vzn/vx-darwin-arm64": "0.0.34"
+    "@vzn/vx-linux-x64": "0.0.35",
+    "@vzn/vx-linux-arm64": "0.0.35",
+    "@vzn/vx-darwin-x64": "0.0.35",
+    "@vzn/vx-darwin-arm64": "0.0.35"
   },
   "dependencies": {
     "@anthropic-ai/sandbox-runtime": "^0.0.76"

package/src/cli/select.ts

@@ -202,7 +202,12 @@ export async function resolveFilters(
 ): Promise<FilterResolution> {
   const root = await findWorkspaceRoot(cwd)
   const projects = await loadWorkspaceProjects(cwd)
-  const parsed = raw.map((r) => parseFilter(r, root))
+  let parsed: ReturnType<typeof parseFilter>[]
+  try {
+    parsed = raw.map((r) => parseFilter(r, root))
+  } catch (err) {
+    return { error: err instanceof Error ? err.message : String(err) }
+  }
   const walksGraph = parsed.some((f) => f.withDeps || f.withDependents || f.onlyDeps)
   // Every reader of the staged configs in this pass — the `pkg#task`
   // edge walk, the `workspaceFiles` owners of a changed path — shares
@@ -244,6 +249,7 @@ export async function resolveFilters(
   }
 
   const unmatched: string[] = []
+  const emptyWalks: string[] = []
   const selected = applyFilters({
     filters: parsed,
     projects,
@@ -255,6 +261,17 @@ export async function resolveFilters(
     onNoMatch: (f) => {
       if (f.gitSince === undefined) unmatched.push(f.raw)
     },
+    // A pattern that matched, with nothing on the walk it asked for: the
+    // fact to say, where "no projects matched" read as a typo (item 1030).
+    onEmptyWalk: (f, matched) => {
+      if (f.negate || f.gitSince !== undefined) return
+      const which = matched.join(', ')
+      emptyWalks.push(
+        f.onlyDeps
+          ? `filter "${f.raw}" matched ${which}, which depends on no project`
+          : `filter "${f.raw}" matched ${which}, and no project depends on it`,
+      )
+    },
   })
   if (selected.size === 0) {
     // "Nothing changed" is a legitimate outcome, not a typo — a docs-only
@@ -273,6 +290,9 @@ export async function resolveFilters(
           : ` — ${self.gitSince} is HEAD itself: compare with the branch you merge into (--affected=origin/main) or the previous commit (--affected=HEAD~1)`
       return { empty: `nothing affected since ${refs}${hint}` }
     }
+    if (unmatched.length === 0 && emptyWalks.length > 0) {
+      return { error: `no projects selected: ${emptyWalks.join('; ')}` }
+    }
     // One line, not a warning per pattern and then an error saying the same:
     // the patterns are in the error, and the nearest project name is the
     // hint a typo needs.

package/src/orchestrator/prepare.ts

@@ -51,6 +51,7 @@ import {
   fingerprintClaims,
   hasHook,
   resolveCache,
+  teardownPlugins,
 } from './plugin-host.js'
 import { loadProjects, loadWorkspacePlugins, type LoadedProjects } from './projects.js'
 import { keyExcludedDependencies } from './excluded-keys.js'
@@ -335,33 +336,152 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
   // layer's own truthful answer; `LayeredCache` sets it, a bare `Cache`
   // doesn't, and a third-party layer opts in when it really has a remote.
   const hasRemoteLayer = cache.hasRemote === true
+  // From here the plugins' factories have run and the cache is open: a
+  // throw (a stage hook, a `^name` nobody declares, a cycle, an unknown
+  // exclude name) closed neither and tore nothing down, once per failed
+  // cycle under `vx watch` (item 1029). run() owns both only once this
+  // returns.
+  try {
+    const gitFilesCache = new GitFilesCache()
+    // Bulk-populate via a single `git ls-files` at the workspace root —
+    // partitions the output by project. Avoids one fork+exec per project
+    // (~5-10ms each on Linux; the dominant cold-start cost on big
+    // monorepos). When any loaded task declares inputs.workspaceFiles,
+    // the enumeration must see every file from the root (no pathspec
+    // scoping) and additionally stores a workspace-wide partition.
+    const usesWorkspaceInputs = [...projects.values()].some((p) =>
+      Object.values(p.config.tasks ?? {}).some(
+        (t) => (t.cache?.inputs.workspaceFiles?.length ?? 0) > 0,
+      ),
+    )
+    const projectDirs = [...projects.values()].map((p) => p.dir)
+    const enumeration = await (earlyGit ??
+      startGitEnumeration(
+        workspaceRoot,
+        gitPathspecs(workspaceRoot, projectDirs, usesWorkspaceInputs),
+      ))
+    applyGitEnumeration(enumeration, workspaceRoot, projectDirs, gitFilesCache, usesWorkspaceInputs)
+    mark('git enumeration')
+    const hashCache = createHashCache()
+    const fingerprintWatch = new FingerprintWatch(workspaceRoot, fingerprints, fingerprintsAt)
 
-  const gitFilesCache = new GitFilesCache()
-  // Bulk-populate via a single `git ls-files` at the workspace root —
-  // partitions the output by project. Avoids one fork+exec per project
-  // (~5-10ms each on Linux; the dominant cold-start cost on big
-  // monorepos). When any loaded task declares inputs.workspaceFiles,
-  // the enumeration must see every file from the root (no pathspec
-  // scoping) and additionally stores a workspace-wide partition.
-  const usesWorkspaceInputs = [...projects.values()].some((p) =>
-    Object.values(p.config.tasks ?? {}).some(
-      (t) => (t.cache?.inputs.workspaceFiles?.length ?? 0) > 0,
-    ),
-  )
-  const projectDirs = [...projects.values()].map((p) => p.dir)
-  const enumeration = await (earlyGit ??
-    startGitEnumeration(
-      workspaceRoot,
-      gitPathspecs(workspaceRoot, projectDirs, usesWorkspaceInputs),
-    ))
-  applyGitEnumeration(enumeration, workspaceRoot, projectDirs, gitFilesCache, usesWorkspaceInputs)
-  mark('git enumeration')
-  const hashCache = createHashCache()
-  const fingerprintWatch = new FingerprintWatch(workspaceRoot, fingerprints, fingerprintsAt)
+    // Empty-cases bookkeeping. We still construct the cache + fingerprint
+    // so the caller's try/finally pattern can close it uniformly.
+    if (requested.length === 0) {
+      return {
+        workspaceRoot,
+        workspaceConfig,
+        plugins,
+        cacheDir,
+        cache,
+        localCache,
+        hasRemoteLayer,
+        priorities: new Map(),
+        nodes: new Map(),
+        unresolvedTasks,
+        projects,
+        anyProjectConfig: projectsWithConfigs.length > 0,
+        workspaceFingerprint,
+        fingerprintWatch,
+        nestedDirsByProject,
+        gitFilesCache,
+        hashCache,
+        workspaceProjectCount: projectMetas.length,
+        empty:
+          options.selectedByDiff === true && unresolvedTasks.length === 0
+            ? 'none-affected'
+            : 'no-tasks-declared',
+      }
+    }
+
+    // The whole graph, whatever `--exclude-dependencies` says: the stages
+    // below shape and key the tasks it drops as a full run would, because
+    // a dropped task is still keyed (excluded-keys.ts). A scoped load is not
+    // the whole workspace: a `^name` nothing loaded declares may be declared
+    // by a config the scope left out, so the builder hands it back instead of
+    // refusing it, and the rest decide.
+    const unproven: Array<[taskId: string, name: string]> = []
+    const nodes = buildTaskGraph({
+      projects,
+      packageGraph,
+      requested,
+      ...(projects.size < projectsWithConfigs.length
+        ? { undeclaredDeps: (id: string, name: string) => void unproven.push([id, name]) }
+        : {}),
+    })
+    if (unproven.length > 0) {
+      await refuseUndeclaredDeps(unproven, () =>
+        loadProjects({ ...loadArgs, seeds: 'all', closure: false, staged: projects }),
+      )
+    }
+    // An `--exclude-dependencies` name no project declares drops nothing:
+    // `=biuld` planned the whole chain and ran it, exit 0 (item 1026). Every
+    // other name the user types must resolve; so must this one. After the
+    // graph, so a config error (`^biuld` nobody declares) is named first.
+    const excludeNames = options.excludeDependencies
+    if (Array.isArray(excludeNames) && excludeNames.length > 0) {
+      const declared = new Set<string>()
+      for (const p of projects.values())
+        for (const t of Object.keys(p.config.tasks ?? {})) declared.add(t)
+      let unknown = excludeNames.filter((n) => !declared.has(n))
+      if (unknown.length > 0 && projects.size < projectsWithConfigs.length) {
+        unknown = await declaredNowhere(unknown, () =>
+          loadProjects({ ...loadArgs, seeds: 'all', closure: false, staged: projects }),
+        )
+      }
+      if (unknown.length > 0) {
+        cache.close()
+        const hints = new Set(unknown.flatMap((n) => nearest(n, declared) ?? []))
+        const hint = hints.size === 0 ? '' : ` Did you mean ${[...hints].join(', ')}?`
+        throw new UserError(
+          `--exclude-dependencies names a task no project declares: ${unknown.join(', ')}.${hint}`,
+        )
+      }
+    }
+    // The graph is built; what follows is the plugins' (graph, key,
+    // schedule). Two rows, so a plugin's key stage reads as its own cost
+    // and not as graph building — a lockfile plugin's 1000 stats per run
+    // hid inside one `prepare (graph)` row until 2026-09-10.
+    mark('build graph')
+    if (hasHook(plugins, 'graph')) {
+      await applyGraphHooks(plugins, nodes, {
+        workspaceRoot,
+        cacheDir,
+        warn: (m) => log.status(m),
+        requested: [...nodes.values()].filter((n) => n.requested).map((n) => n.id),
+      })
+    }
+    if (hasHook(plugins, 'key')) {
+      await applyKeyHooks(plugins, nodes, { workspaceRoot, cacheDir, warn: (m) => log.status(m) })
+    }
+    const exclude = options.excludeDependencies
+    if (exclude !== undefined && (exclude === 'all' || exclude.length > 0)) {
+      const { keyOnly, dropped } = excludeDependencies(nodes, exclude)
+      if (dropped.size > 0) {
+        await keyExcludedDependencies({
+          nodes,
+          keyOnly,
+          dropped,
+          cache,
+          workspaceRoot,
+          workspaceFingerprint,
+          forwardArgs: options.forwardArgs,
+          nestedDirsByProject,
+          gitFilesCache,
+          hashCache,
+        })
+      }
+    }
+    let priorities: ReadonlyMap<string, number> = new Map()
+    if (hasHook(plugins, 'schedule')) {
+      priorities = await applyScheduleHooks(plugins, nodes, {
+        workspaceRoot,
+        cacheDir,
+        warn: (m) => log.status(m),
+        localCache,
+      })
+    }
 
-  // Empty-cases bookkeeping. We still construct the cache + fingerprint
-  // so the caller's try/finally pattern can close it uniformly.
-  if (requested.length === 0) {
     return {
       workspaceRoot,
       workspaceConfig,
@@ -370,8 +490,8 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
       cache,
       localCache,
       hasRemoteLayer,
-      priorities: new Map(),
-      nodes: new Map(),
+      priorities,
+      nodes,
       unresolvedTasks,
       projects,
       anyProjectConfig: projectsWithConfigs.length > 0,
@@ -381,121 +501,12 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
       gitFilesCache,
       hashCache,
       workspaceProjectCount: projectMetas.length,
-      empty:
-        options.selectedByDiff === true && unresolvedTasks.length === 0
-          ? 'none-affected'
-          : 'no-tasks-declared',
-    }
-  }
-
-  // The whole graph, whatever `--exclude-dependencies` says: the stages
-  // below shape and key the tasks it drops as a full run would, because
-  // a dropped task is still keyed (excluded-keys.ts). A scoped load is not
-  // the whole workspace: a `^name` nothing loaded declares may be declared
-  // by a config the scope left out, so the builder hands it back instead of
-  // refusing it, and the rest decide.
-  const unproven: Array<[taskId: string, name: string]> = []
-  const nodes = buildTaskGraph({
-    projects,
-    packageGraph,
-    requested,
-    ...(projects.size < projectsWithConfigs.length
-      ? { undeclaredDeps: (id: string, name: string) => void unproven.push([id, name]) }
-      : {}),
-  })
-  if (unproven.length > 0) {
-    await refuseUndeclaredDeps(unproven, () =>
-      loadProjects({ ...loadArgs, seeds: 'all', closure: false, staged: projects }),
-    )
-  }
-  // An `--exclude-dependencies` name no project declares drops nothing:
-  // `=biuld` planned the whole chain and ran it, exit 0 (item 1026). Every
-  // other name the user types must resolve; so must this one. After the
-  // graph, so a config error (`^biuld` nobody declares) is named first.
-  const excludeNames = options.excludeDependencies
-  if (Array.isArray(excludeNames) && excludeNames.length > 0) {
-    const declared = new Set<string>()
-    for (const p of projects.values())
-      for (const t of Object.keys(p.config.tasks ?? {})) declared.add(t)
-    let unknown = excludeNames.filter((n) => !declared.has(n))
-    if (unknown.length > 0 && projects.size < projectsWithConfigs.length) {
-      unknown = await declaredNowhere(unknown, () =>
-        loadProjects({ ...loadArgs, seeds: 'all', closure: false, staged: projects }),
-      )
+      empty: nodes.size === 0 ? 'empty-graph' : null,
     }
-    if (unknown.length > 0) {
-      cache.close()
-      const hints = new Set(unknown.flatMap((n) => nearest(n, declared) ?? []))
-      const hint = hints.size === 0 ? '' : ` Did you mean ${[...hints].join(', ')}?`
-      throw new UserError(
-        `--exclude-dependencies names a task no project declares: ${unknown.join(', ')}.${hint}`,
-      )
-    }
-  }
-  // The graph is built; what follows is the plugins' (graph, key,
-  // schedule). Two rows, so a plugin's key stage reads as its own cost
-  // and not as graph building — a lockfile plugin's 1000 stats per run
-  // hid inside one `prepare (graph)` row until 2026-09-10.
-  mark('build graph')
-  if (hasHook(plugins, 'graph')) {
-    await applyGraphHooks(plugins, nodes, {
-      workspaceRoot,
-      cacheDir,
-      warn: (m) => log.status(m),
-      requested: [...nodes.values()].filter((n) => n.requested).map((n) => n.id),
-    })
-  }
-  if (hasHook(plugins, 'key')) {
-    await applyKeyHooks(plugins, nodes, { workspaceRoot, cacheDir, warn: (m) => log.status(m) })
-  }
-  const exclude = options.excludeDependencies
-  if (exclude !== undefined && (exclude === 'all' || exclude.length > 0)) {
-    const { keyOnly, dropped } = excludeDependencies(nodes, exclude)
-    if (dropped.size > 0) {
-      await keyExcludedDependencies({
-        nodes,
-        keyOnly,
-        dropped,
-        cache,
-        workspaceRoot,
-        workspaceFingerprint,
-        forwardArgs: options.forwardArgs,
-        nestedDirsByProject,
-        gitFilesCache,
-        hashCache,
-      })
-    }
-  }
-  let priorities: ReadonlyMap<string, number> = new Map()
-  if (hasHook(plugins, 'schedule')) {
-    priorities = await applyScheduleHooks(plugins, nodes, {
-      workspaceRoot,
-      cacheDir,
-      warn: (m) => log.status(m),
-      localCache,
-    })
-  }
-
-  return {
-    workspaceRoot,
-    workspaceConfig,
-    plugins,
-    cacheDir,
-    cache,
-    localCache,
-    hasRemoteLayer,
-    priorities,
-    nodes,
-    unresolvedTasks,
-    projects,
-    anyProjectConfig: projectsWithConfigs.length > 0,
-    workspaceFingerprint,
-    fingerprintWatch,
-    nestedDirsByProject,
-    gitFilesCache,
-    hashCache,
-    workspaceProjectCount: projectMetas.length,
-    empty: nodes.size === 0 ? 'empty-graph' : null,
+  } catch (err) {
+    await teardownPlugins(plugins, (m) => log.status(m))
+    cache.close()
+    throw err
   }
 }
 

package/src/workspace/filter.ts

@@ -17,7 +17,7 @@
 // given, the base set is "all projects" and excluded packages are removed.
 
 import path from 'node:path'
-import { BUN_GLOB_WILDCARDS } from '../util/index.js'
+import { BUN_GLOB_WILDCARDS, UserError } from '../util/index.js'
 import type { PackageGraph } from './package-graph.js'
 import type { ProjectMeta } from './workspace.js'
 
@@ -82,6 +82,12 @@ export function parseFilter(raw: string, workspaceRoot: string): ParsedFilter {
     }
   }
 
+  // `...`, `!`, `^...`: the operators with no project between them. An
+  // empty name glob matched nothing and was hinted "Did you mean a?", and
+  // an empty exclude (`!$UNSET`) excluded nothing, so every project ran
+  // with one warning line (item 1030).
+  if (s === '') throw new UserError(`filter "${raw}" names no project`)
+
   let isPath = false
   let matcher = s
   let pathGlob: Bun.Glob | undefined
@@ -191,6 +197,12 @@ export interface ApplyFiltersOptions {
    * several filters silently under-selects.
    */
   onNoMatch?: (filter: ParsedFilter) => void
+  /**
+   * Called once per filter whose pattern matched projects but whose walk
+   * selected none (`...^c` for a `c` nothing depends on), with what it
+   * matched. Reported as a no-match, it read as a typo (item 1030).
+   */
+  onEmptyWalk?: (filter: ParsedFilter, matched: readonly string[]) => void
 }
 
 export function applyFilters(opts: ApplyFiltersOptions): Set<string> {
@@ -216,6 +228,7 @@ export function applyFilters(opts: ApplyFiltersOptions): Set<string> {
         for (const d of opts.graph.transitiveDependents(name)) expanded.add(d)
       }
     }
+    if (matched.length > 0 && expanded.size === 0) opts.onEmptyWalk?.(f, matched)
     if (f.negate) excludes.push(expanded)
     else for (const name of expanded) selected.add(name)
   }