@vzn/vx 0.0.533 → 0.0.535

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vzn/vx",
-  "version": "0.0.533",
+  "version": "0.0.535",
   "description": "The fastest task runner and build cache for JavaScript monorepos.",
   "type": "module",
   "exports": {
@@ -21,10 +21,10 @@
     "node": ">=18"
   },
   "optionalDependencies": {
-    "@vzn/vx-linux-x64": "0.0.533",
-    "@vzn/vx-linux-arm64": "0.0.533",
-    "@vzn/vx-darwin-x64": "0.0.533",
-    "@vzn/vx-darwin-arm64": "0.0.533"
+    "@vzn/vx-linux-x64": "0.0.535",
+    "@vzn/vx-linux-arm64": "0.0.535",
+    "@vzn/vx-darwin-x64": "0.0.535",
+    "@vzn/vx-darwin-arm64": "0.0.535"
   },
   "dependencies": {
     "@anthropic-ai/sandbox-runtime": "^0.0.76"

package/src/cli/run.ts

@@ -498,6 +498,7 @@ export async function resolveRunOptions(
   let discovered: RunOptions['discovered']
   let selectedByDiff = false
   let affected: RunOptions['affected']
+  let outright: string[] | undefined
   if (bareTasks.length === 0) {
     projects = undefined
   } else if (filterStrings.length > 0) {
@@ -528,6 +529,7 @@ export async function resolveRunOptions(
       staged = resolved.staged
       discovered = resolved.discovered
       affected = resolved.affected
+      outright = resolved.outright
     }
   } else if (parsed.all) {
     projects = undefined
@@ -573,6 +575,7 @@ export async function resolveRunOptions(
   if (projects !== undefined) opts.projects = projects
   if (selectedByDiff) opts.selectedByDiff = true
   if (affected !== undefined) opts.affected = affected
+  if (outright !== undefined) opts.selectedOutright = outright
   if (staged !== undefined) opts.staged = staged
   if (discovered !== undefined) opts.discovered = discovered
   if (parsed.retries !== undefined) opts.retries = parsed.retries

package/src/cli/select.ts

@@ -182,6 +182,8 @@ export type FilterResolution =
       discovered: { root: string; projects: ProjectMeta[] }
       /** The `affected` filter's diff, for the run to seed its tasks from (`RunOptions.affected`). */
       affected?: AffectedChanges
+      /** What the other includes selected (`RunOptions.selectedOutright`). */
+      outright?: string[]
     }
   | { error: string }
   | { empty: string }
@@ -367,6 +369,22 @@ export async function resolveFilters(
     process.stderr.write(
       `vx: filter "${f}" matched no projects${didYouMean([f], projects, tags)}\n`,
     )
+  // Each include is a union: what `--filter other` selected runs its tasks
+  // whether or not the `--affected` diff reaches them, and an exclude
+  // still removes it (X-10).
+  const others = parsed.filter((f) => f.negate || f.raw !== affected)
+  const outright =
+    changes !== undefined && others.some((f) => !f.negate)
+      ? [
+          ...applyFilters({
+            filters: others,
+            projects,
+            graph,
+            affectedByFilter,
+            ...(tags !== undefined ? { tags } : {}),
+          }),
+        ].filter((n) => selected.has(n))
+      : []
   let staged: Map<string, ProjectEntry> | undefined
   if (stagedPromise !== undefined) {
     try {
@@ -382,6 +400,7 @@ export async function resolveFilters(
     ...(staged !== undefined ? { staged } : {}),
     discovered: { root, projects },
     ...(changes !== undefined ? { affected: changes } : {}),
+    ...(outright.length > 0 ? { outright: outright.sort() } : {}),
   }
 }
 

package/src/cli/show.ts

@@ -266,8 +266,11 @@ function renderProject(
     return `${JSON.stringify(JSON.parse(JSON.stringify({ name, dir, config: shown })), null, 2)}\n`
   }
   const tags = config?.tags ?? []
-  const head = `${name} — ${dir}${tags.length > 0 ? `\n  tags: ${tags.join(', ')}` : ''}`
   const tasks = Object.entries(config?.tasks ?? {})
+  const head = `${name} — ${dir}${tags.length > 0 ? `\n  tags: ${tags.join(', ')}` : ''}${
+    // A config-less package a dependant reaches has the default `build` (X-9).
+    hasConfigFile || tasks.length === 0 ? '' : '\n  (no vx config)'
+  }`
   if (tasks.length === 0)
     return `${head}\n  ${hasConfigFile ? '(no tasks declared)' : '(no vx config)'}\n`
   const blocks = tasks.map(([taskName, task]) => taskBlock(taskName, task))

package/src/orchestrator/options.ts

@@ -35,6 +35,12 @@ export interface RunOptions {
    * 2026-10-04). `projects` is the candidate set it narrows.
    */
   affected?: AffectedChanges
+  /**
+   * The projects an include other than `--affected` selected (`--filter
+   * other`): every include is a union, so their requested tasks run
+   * whether or not `affected` reaches them (X-10).
+   */
+  selectedOutright?: readonly string[]
   /**
    * Configs a selection pass in this same process already loaded and
    * staged with the same `cacheDir` and `frozen` (the CLI walks every

package/src/orchestrator/prepare.ts

@@ -521,9 +521,12 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
     // closure; a `pkg#task` the user named runs as it always does.
     if (options.affected !== undefined) {
       const named = new Set(tasks.filter((t) => t.includes('#')))
+      const outright = new Set(options.selectedOutright)
       const ids = requested.map((r) => `${r.project}#${r.task}`)
       const reached = new Set(affectedRoots(nodes, ids, options.affected, projects, packageGraph))
-      const kept = requested.filter((_r, i) => named.has(ids[i]!) || reached.has(ids[i]!))
+      const kept = requested.filter(
+        (r, i) => named.has(ids[i]!) || outright.has(r.project) || reached.has(ids[i]!),
+      )
       if (kept.length === 0) return emptyRun('none-affected')
       if (kept.length < requested.length) {
         unproven.length = 0

package/src/orchestrator/projects.ts

@@ -179,13 +179,16 @@ export async function loadProjects(args: LoadProjectsArgs): Promise<LoadedProjec
   // scripts mapped onto packages that never wrote a `vx.config.ts`). It
   // then loads as `{ tasks: {} }` — nothing to evaluate, nothing to freeze
   // — and the stage runs on that like on any loaded config. With no
-  // `project` plugin a plain run never visits (or fences, or seeds) a
-  // config-less package.
+  // `project` plugin a plain run never seeds (or fences) a config-less
+  // package, but loads one a loaded project's closure reaches: it gets the
+  // default `build`, so a dependant bundling its source is keyed on it
+  // behind `^build`. Left out, its edit replayed the dependant's stale
+  // output as a hit (X-9).
   const projectStage = hasHook(plugins, 'project')
   const configured = args.projectMetas.filter(
     (m) => projectStage || (typeof m.configPath === 'string' && m.configPath.length > 0),
   )
-  const metaByName = new Map<string, ProjectMeta>(configured.map((m) => [m.name, m]))
+  const metaByName = new Map<string, ProjectMeta>(args.projectMetas.map((m) => [m.name, m]))
   const needed = new Set<string>()
   const pending: ProjectMeta[] = []
   // Counted, not read off `pending`: a round empties `pending`, and a guard
@@ -212,10 +215,11 @@ export async function loadProjects(args: LoadProjectsArgs): Promise<LoadedProjec
     walked.add(name)
     for (const dep of packageGraph.transitiveDeps(name)) consider(dep)
   }
-  const seeds = args.seeds === 'all' ? metaByName.keys() : [...args.seeds]
+  const seedAll = (): Iterable<string> => configured.map((m) => m.name)
+  const seeds = args.seeds === 'all' ? seedAll() : [...args.seeds]
   for (const seed of seeds) consider(seed)
   if (graph !== null && pending.length < metaByName.size) {
-    for (const seed of args.seeds === 'all' ? metaByName.keys() : seeds) {
+    for (const seed of args.seeds === 'all' ? seedAll() : seeds) {
       considerWithDeps(graph, seed)
     }
   }