@vzn/vx 0.0.23 → 0.0.25

package/package.json

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

package/src/cli/watch.ts

@@ -549,11 +549,13 @@ export async function watchCmd(args: readonly string[]): Promise<number> {
     // scope is the one resolved at start; a new package joins it only as a
     // dependency of it.
     rediscover: async () => {
-      const all = await listProjects(await loadWorkspace(workspaceRoot))
+      const workspace = await loadWorkspace(workspaceRoot)
+      const all = await listProjects(workspace)
       const sweep = await sweepConfigs(all, workspaceRoot, load)
       const now = await watchedProjects(workspaceRoot, all, inScope(all), load, sweep.staged)
       return {
         projects: now,
+        memberBases: memberBaseDirs(workspace),
         workspaceWide: sweep.workspaceWide,
         workspaceInputs: sweep.workspaceInputs,
         outputs: sweep.outputs,
@@ -762,7 +764,10 @@ export function makeRootEventFilter(
     // this line load-bearing.
     if (
       !rel.includes('/') &&
-      (isWorkspaceFingerprintFile(rel) || isWorkspaceConfigFile(rel) || claimedRootFiles.has(rel))
+      (isWorkspaceFingerprintFile(rel) ||
+        isWorkspaceConfigFile(rel) ||
+        rel === 'package.json' ||
+        claimedRootFiles.has(rel))
     ) {
       return true
     }
@@ -804,7 +809,7 @@ interface WatchLoopArgs {
    * loaded once per process, so the set is fixed for the loop.
    */
   claimedRootFiles: ReadonlySet<string>
-  /** The directory each `<dir>/*` package glob names; a member coming or going there is a cycle. */
+  /** The directory each `<dir>/*` package glob names at start; a member coming or going there is a cycle. */
   memberBases: readonly string[]
   /** Every package's directory, in scope or not: a member base's other entries are packages still to come. */
   packageDirs: ReadonlySet<string>
@@ -814,6 +819,7 @@ interface WatchLoopArgs {
 
 interface Rediscovered {
   projects: readonly ProjectMeta[]
+  memberBases: readonly string[]
   workspaceWide: boolean
   workspaceInputs: readonly string[]
   outputs: ReadonlyMap<string, readonly string[]>
@@ -833,21 +839,29 @@ const PROJECT_CONFIGS: ReadonlySet<string> = new Set(PROJECT_CONFIG_FILENAMES)
  * watcher, a new output must stop being an event) or the workspace config
  * (a plugin's `project` stage). Until item 891 only a member directory
  * coming or going re-read the set, so each of these waited for a restart
- * while the loop looked alive.
+ * while the loop looked alive. A root fingerprint file too, for
+ * `pnpm-workspace.yaml`: a glob added there was a cycle that ran the new
+ * packages and watched none of them (item 1018).
  */
 function shapesWatchedSet(filename: string): boolean {
   const base = path.basename(filename)
-  return base === 'package.json' || PROJECT_CONFIGS.has(base) || isWorkspaceConfigFile(base)
+  return (
+    base === 'package.json' ||
+    isWorkspaceFingerprintFile(base) ||
+    PROJECT_CONFIGS.has(base) ||
+    isWorkspaceConfigFile(base)
+  )
 }
 
 const CLOSED: WatchHandle = { close() {} }
 
 async function runWatchLoop(args: WatchLoopArgs): Promise<number> {
-  const { opts, stop, workspaceRoot, projects, cacheDir, memberBases } = args
+  const { opts, stop, workspaceRoot, projects, cacheDir } = args
   // The watched set as of the last cycle: `rearm` replaces these after an
   // event that can change it, and every filter below reads the current one.
   let workspaceWide = args.workspaceWide
   let packageDirs = args.packageDirs
+  let memberBases = args.memberBases
   let projectDirs = args.projectDirs
   let workspaceInputs = args.workspaceInputs
   let outputs = args.outputs
@@ -1185,6 +1199,7 @@ async function runWatchLoop(args: WatchLoopArgs): Promise<number> {
             if (
               isWorkspaceFingerprintFile(filename) ||
               isWorkspaceConfigFile(filename) ||
+              filename === 'package.json' ||
               args.claimedRootFiles.has(filename)
             ) {
               if (shapesWatchedSet(filename) || filename === LOCKFILE_NAME) reread = true
@@ -1334,6 +1349,8 @@ async function runWatchLoop(args: WatchLoopArgs): Promise<number> {
     configImportFiles = next.configImports
     wsConfigImportFiles = next.workspaceConfigImports
     packageDirs = next.packageDirs
+    memberBases = next.memberBases
+    armBases()
     isIgnoredPath = makeWatchIgnore(cacheDir, outputs, inputs)
     matters = makeRootEventFilter(
       workspaceRoot,
@@ -1373,28 +1390,45 @@ async function runWatchLoop(args: WatchLoopArgs): Promise<number> {
   // triggers re-reads the workspace (`rearm`) so the new package's own
   // edits are cycles from then on. Until 2026-09-10 the watched set was
   // fixed when the loop armed: the next cycle ran the new package, and
-  // every edit inside it after that was silence.
-  for (const base of memberBases) {
-    let members = memberEntries(base)
-    try {
-      arm(base, false, (filename) => {
-        if (isIgnoredWatchPath(filename)) return
-        // Only a member coming or going. On macOS a non-recursive watcher
-        // also reports a member whose CONTENTS changed (FSEvents names the
-        // directory a write landed in), so a task writing into its own
-        // project — or the arm's own probe file — read as a member event and
-        // cost an uncached task one execution per cycle (CI, 2026-09-10).
-        const now = memberEntries(base)
-        if (sameMembers(members, now)) return
-        members = now
-        reread = true
-        trigger(`${path.relative(workspaceRoot, base)}/${filename}`, path.join(base, filename))
-      })
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err)
-      process.stderr.write(`vx watch: cannot watch ${base}: ${msg}\n`)
+  // every edit inside it after that was silence. The bases themselves are
+  // re-read with the set: a glob added to the list watched nothing new
+  // until a restart (item 1018).
+  const baseArms = new Map<string, WatchHandle>()
+  const armBases = (): void => {
+    const want = new Set(memberBases)
+    for (const [base, handle] of baseArms) {
+      if (want.has(base)) continue
+      handle.close()
+      baseArms.delete(base)
+    }
+    for (const base of want) {
+      if (baseArms.has(base)) continue
+      let members = memberEntries(base)
+      try {
+        baseArms.set(
+          base,
+          arm(base, false, (filename) => {
+            if (isIgnoredWatchPath(filename)) return
+            // Only a member coming or going. On macOS a non-recursive watcher
+            // also reports a member whose CONTENTS changed (FSEvents names the
+            // directory a write landed in), so a task writing into its own
+            // project — or the arm's own probe file — read as a member event
+            // and cost an uncached task one execution per cycle (CI,
+            // 2026-09-10).
+            const now = memberEntries(base)
+            if (sameMembers(members, now)) return
+            members = now
+            reread = true
+            trigger(`${path.relative(workspaceRoot, base)}/${filename}`, path.join(base, filename))
+          }),
+        )
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err)
+        process.stderr.write(`vx watch: cannot watch ${base}: ${msg}\n`)
+      }
     }
   }
+  armBases()
   armPending(false)
   armImports()
 

package/src/graph/task-graph.ts

@@ -30,6 +30,13 @@ export interface TaskNode {
   config: TaskConfig
   /** Ids of tasks that must complete before this one runs. */
   deps: string[]
+  /**
+   * The members of `deps` that order the run and fold into no key:
+   * `--exclude-dependencies` dropped a task between this one and them
+   * (`excludeDependencies`). The dropped task's derived key already folds
+   * theirs, so folding them again would give a key no full run derives.
+   */
+  orderOnly?: string[]
   /**
    * True for the tasks the user actually asked for (via cwd, `--all`,
    * `--filter`, or `pkg#task`). False for deps pulled in by `dependsOn`
@@ -588,6 +595,27 @@ export function excludeDependencies(
     if (lost.length === 0) continue
     dropped.set(id, lost)
     node.deps = node.deps.filter(stays)
+    // A scheduled task reached through a dropped one still runs first: in
+    // `test → gen → build` with `gen` excluded and `build` requested, the
+    // edge to `gen` went and nothing ordered `test` after `build`, so the
+    // two ran at once (item 1019). The walk reads unscheduled nodes only,
+    // whose deps this loop leaves as they are.
+    const order = new Set<string>()
+    const seen = new Set<string>()
+    const stack = [...lost]
+    while (stack.length > 0) {
+      const dep = stack.pop()!
+      if (seen.has(dep)) continue
+      seen.add(dep)
+      if (scheduled.has(dep)) {
+        if (!node.deps.includes(dep)) order.add(dep)
+        continue
+      }
+      stack.push(...nodes.get(dep)!.deps)
+    }
+    if (order.size === 0) continue
+    node.orderOnly = [...order].sort()
+    node.deps = [...node.deps, ...node.orderOnly].sort()
   }
   for (const id of keyOnly.keys()) nodes.delete(id)
   return { keyOnly, dropped }

package/src/orchestrator/excluded-keys.ts

@@ -16,7 +16,7 @@
 import type { CacheLayer, GitFilesCache } from '../cache/index.js'
 import { isGroupTask, type TaskNode, type TaskOutcome } from '../graph/index.js'
 import { computeGroupHash, computeTaskHash, type HashCache } from './task-hash.js'
-import { filterUpstreamHashes } from './upstream.js'
+import { filterUpstreamHashes, keyedDeps } from './upstream.js'
 
 export interface KeyExcludedArgs {
   /** The scheduled graph, after `excludeDependencies`. */
@@ -41,7 +41,7 @@ export interface KeyExcludedArgs {
 export async function keyExcludedDependencies(args: KeyExcludedArgs): Promise<void> {
   const nodeOf = (id: string): TaskNode => args.nodes.get(id) ?? args.keyOnly.get(id)!
   const fullDeps = (node: TaskNode): readonly string[] => [
-    ...node.deps,
+    ...keyedDeps(node),
     ...(args.dropped.get(node.id) ?? []),
   ]
   // Each key's promise is made after its dependencies' promises, in a

package/src/orchestrator/upstream.ts

@@ -17,7 +17,15 @@ import { UserError } from '../util/index.js'
  * a key at one of them and not the others.
  */
 export function keyUpstream(node: TaskNode, upstream: TaskOutcome[]): TaskOutcome[] {
-  return node.excludedUpstream === undefined ? upstream : [...upstream, ...node.excludedUpstream]
+  const order = node.orderOnly
+  const keyed = order === undefined ? upstream : upstream.filter((o) => !order.includes(o.node.id))
+  return node.excludedUpstream === undefined ? keyed : [...keyed, ...node.excludedUpstream]
+}
+
+/** `node.deps` less its ordering-only edges: the dependencies a key may fold. */
+export function keyedDeps(node: TaskNode): readonly string[] {
+  const order = node.orderOnly
+  return order === undefined ? node.deps : node.deps.filter((d) => !order.includes(d))
 }
 
 /**