@vzn/vx 0.0.24 → 0.0.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vzn/vx",
-  "version": "0.0.24",
+  "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.24",
-    "@vzn/vx-linux-arm64": "0.0.24",
-    "@vzn/vx-darwin-x64": "0.0.24",
-    "@vzn/vx-darwin-arm64": "0.0.24"
+    "@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/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))
 }
 
 /**