@vzn/vx 0.0.132 → 0.0.134

package/package.json

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

package/src/cli/plan-format.ts

@@ -96,11 +96,25 @@ export function formatPlanText(plan: RunPlan): string {
   return lines.join('\n') + '\n'
 }
 
+/** One task of `vx run --dry=json`: the wire, stated by `schemas/plan.json`. */
+export interface PlanTaskJson {
+  id: string
+  project: string
+  task: string
+  hash: string
+  cacheStatus: CacheStatus
+  deps: readonly string[]
+  p50Ms?: number
+  executor?: string
+  download?: 'deferred'
+  description?: string
+}
+
 export function formatPlanJson(plan: RunPlan): string {
   return (
     JSON.stringify(
       {
-        tasks: plan.tasks.map((t) => ({
+        tasks: plan.tasks.map((t): PlanTaskJson => ({
           id: t.node.id,
           project: t.node.projectName,
           task: t.node.taskName,

package/src/orchestrator/keyed-projects.ts

@@ -6,7 +6,7 @@
 // selection the hash path applies (`selectFoldedDeps`).
 
 import { isGroupTask, type TaskNode } from '../graph/index.js'
-import { selectFoldedDeps, type FoldCandidate } from './upstream.js'
+import { keyedDeps, selectFoldedDeps, type FoldCandidate } from './upstream.js'
 
 /**
  * A run's keyed-set lookup: for a task, the directories of every project
@@ -31,7 +31,9 @@ import { selectFoldedDeps, type FoldCandidate } from './upstream.js'
  */
 export function keyedProjects(
   nodes: ReadonlyMap<string, TaskNode>,
+  keyOnly: ReadonlyMap<string, TaskNode> = new Map(),
 ): (node: TaskNode) => ReadonlySet<string> {
+  const nodeOf = (id: string): TaskNode => nodes.get(id) ?? keyOnly.get(id)!
   const below = new Map<string, ReadonlySet<string>>()
   // Post-order on an explicit stack: a fold is as deep as the graph, and a
   // recursion per edge threw `RangeError` at the 50,000 the builder takes
@@ -47,7 +49,7 @@ export function keyedProjects(
         continue
       }
       if (deps === undefined) {
-        frame[1] = folded(node, nodes)
+        frame[1] = folded(node, nodeOf)
         for (const { node: dep } of frame[1]) if (!below.has(dep.id)) stack.push([dep, undefined])
         continue
       }
@@ -63,11 +65,22 @@ export function keyedProjects(
   }
 }
 
-/** The dependencies `node`'s key folds, per the hash path's rules above. */
-function folded(node: TaskNode, nodes: ReadonlyMap<string, TaskNode>): FoldCandidate[] {
+/**
+ * The dependencies `node`'s key folds, per the hash path's rules above, as
+ * `keyUpstream` hands them to the key: the scheduled ones less the edges
+ * `--exclude-dependencies` left for order alone, plus the dropped ones it
+ * keys all the same (`excludedUpstream`), whose own dependencies the walk
+ * reads from the run's `keyOnly` map. `node.deps` held the order-only
+ * edges and lacked the dropped ones: the sandbox granted a sibling the key
+ * does not answer for.
+ */
+function folded(node: TaskNode, nodeOf: (id: string) => TaskNode): FoldCandidate[] {
   const candidates: FoldCandidate[] = []
-  for (const id of node.deps) {
-    const dep = nodes.get(id)!
+  for (const id of keyedDeps(node)) {
+    const dep = nodeOf(id)
+    candidates.push({ node: dep, unit: foldUnit(dep) })
+  }
+  for (const { node: dep } of node.excludedUpstream ?? []) {
     candidates.push({ node: dep, unit: foldUnit(dep) })
   }
   if (isGroupTask(node)) return candidates

package/src/orchestrator/prepare.ts

@@ -89,6 +89,11 @@ export interface PreparedRun {
    */
   priorities: ReadonlyMap<string, number>
   nodes: Map<string, TaskNode>
+  /**
+   * The tasks `--exclude-dependencies` took out of the schedule: keyed as a
+   * full run keys them, never run. Empty without the flag.
+   */
+  keyOnly: ReadonlyMap<string, TaskNode>
   /**
    * Requested task specs that matched NO project — a typo, or a stray
    * positional (the value of an `=`-only flag written with a space).
@@ -391,6 +396,7 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
         hasRemoteLayer,
         priorities: new Map(),
         nodes: new Map(),
+        keyOnly: new Map(),
         unresolvedTasks,
         projects,
         anyProjectConfig: projectsWithConfigs.length > 0,
@@ -469,8 +475,11 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
       await applyKeyHooks(plugins, nodes, { workspaceRoot, cacheDir, warn: (m) => log.status(m) })
     }
     const exclude = options.excludeDependencies
+    let keyOnly: ReadonlyMap<string, TaskNode> = new Map()
     if (exclude !== undefined && (exclude === 'all' || exclude.length > 0)) {
-      const { keyOnly, dropped } = excludeDependencies(nodes, exclude)
+      const split = excludeDependencies(nodes, exclude)
+      keyOnly = split.keyOnly
+      const dropped = split.dropped
       if (dropped.size > 0) {
         await keyExcludedDependencies({
           nodes,
@@ -506,6 +515,7 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
       hasRemoteLayer,
       priorities,
       nodes,
+      keyOnly,
       unresolvedTasks,
       projects,
       anyProjectConfig: projectsWithConfigs.length > 0,

package/src/orchestrator/run.ts

@@ -618,7 +618,7 @@ async function runOnBus(
     }
 
     const sandboxArmer = prepareSandbox(nodes.values())
-    const keyed = keyedProjects(nodes)
+    const keyed = keyedProjects(nodes, prepared.keyOnly)
     const outputDirSnapshots: OutputDirSnapshot[] = []
     // Saves run off the execution slot, twice the cap at once (memory:
     // each pack holds an artifact's bytes); a failed save is a miss next

package/src/workspace/config-imports.ts

@@ -20,12 +20,13 @@
 //     the lockfile moves, which the workspace fingerprint already covers.
 //     A tsconfig `paths` / `baseUrl` alias is the exception: Bun loads it
 //     from disk (D-27).
-//   - Descend only through files owned by NO project. A config reaching into
-//     another project (say a site's `vx.config.ts` importing
-//     `../core/src/index.ts`) records that edge and STOPS there — following
-//     it would drag substantially all of that project's `src/` into the
-//     closure, and the containment channel already selects the project that
-//     owns it.
+//   - Descend only through files owned by NO project, or by a ROOT project
+//     (whose own files are the shared tooling that is otherwise unowned,
+//     D-41). A config reaching into another project (say a site's
+//     `vx.config.ts` importing `../core/src/index.ts`) records that edge
+//     and STOPS there — following it would drag substantially all of that
+//     project's `src/` into the closure, and the containment channel
+//     already selects the project that owns it.
 
 import { existsSync, readFileSync, realpathSync, statSync } from 'node:fs'
 import { realpath } from 'node:fs/promises'
@@ -452,6 +453,9 @@ export async function configImportOwners(a: ConfigImportOwnersArgs): Promise<Set
   )
   if (roots.size === 0) return selected
   const dirToName = await realDirIndex(a.projects, a.realDirs)
+  // A root project owns every file no member owns: the shared tooling the
+  // walk descends through when the root is no project (D-41).
+  const rootOwner = dirToName.get(workspaceRoot)
 
   // target → the files that import it. Reversed up front so one BFS from the
   // changed set answers every root at once, instead of a walk per root.
@@ -484,8 +488,10 @@ export async function configImportOwners(a: ConfigImportOwnersArgs): Promise<Set
         const list = importedBy.get(target)
         if (list) list.push(file)
         else importedBy.set(target, [file])
-        // Descend ONLY through unowned files — see the header.
-        if (ownerOf(target, dirToName) === undefined) frontier.push(target)
+        // Descend ONLY through unowned files, or the root project's own:
+        // see the header.
+        const owner = ownerOf(target, dirToName)
+        if (owner === undefined || owner === rootOwner) frontier.push(target)
       }
     }
   }