@vzn/vx 0.0.582 → 0.0.585

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vzn/vx",
-  "version": "0.0.582",
+  "version": "0.0.585",
   "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.582",
-    "@vzn/vx-linux-arm64": "0.0.582",
-    "@vzn/vx-darwin-x64": "0.0.582",
-    "@vzn/vx-darwin-arm64": "0.0.582"
+    "@vzn/vx-linux-x64": "0.0.585",
+    "@vzn/vx-linux-arm64": "0.0.585",
+    "@vzn/vx-darwin-x64": "0.0.585",
+    "@vzn/vx-darwin-arm64": "0.0.585"
   },
   "dependencies": {
     "@anthropic-ai/sandbox-runtime": "^0.0.76"

package/src/cli/watch-filter.ts

@@ -270,10 +270,9 @@ export function makeRootEventFilter(
  * project nested there: the key's boundary (`computeNestedProjectDirs`)
  * leaves such a file out, so it is no edit of `ownDir`'s. A root project
  * watched its whole tree and ran a cycle for every edit in a nested one
- * (X-42). The fences are the projects with a config, which fence a key
- * whatever the plugins; a config-less one may not, and an edit there
- * still counts. The fence's own config is let through: it coming or going
- * moves the boundary, and the cycle it starts re-reads the set.
+ * (X-42). The fences are every project, config or not, as the key's are
+ * (X-57). The fence's own config is let through: it may give the project
+ * tasks, and the cycle it starts re-reads the set.
  */
 export function makeFence(fenceDirs: readonly string[]): (ownDir: string, abs: string) => boolean {
   const fences = fenceDirs.map((d) => path.resolve(d))

package/src/cli/watch.ts

@@ -316,14 +316,13 @@ interface WatchLoopArgs {
   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>
-  /** Every project with a config, in scope or not: a project's key leaves out what lies in one nested under it. */
+  /** Every project, in scope or not: a project's key leaves out what lies in one nested under it. */
   fenceDirs: readonly string[]
   /** The watched set again, after a cycle that followed an event which can change it. */
   rediscover: () => Promise<Rediscovered>
 }
 
-const fenceDirs = (all: readonly ProjectMeta[]): string[] =>
-  all.filter((p) => p.configPath !== null).map((p) => p.dir)
+const fenceDirs = (all: readonly ProjectMeta[]): string[] => all.map((p) => p.dir)
 
 interface Rediscovered {
   projects: readonly ProjectMeta[]

package/src/graph/scheduler.ts

@@ -267,6 +267,9 @@ export interface ScheduleOptions {
    *     output is reported `cache-hit` regardless of a dep failing);
    *   - leaves the tier when `execute` throws `RestoreDemoted`, and is
    *     dispatched again once its deps are done, with the dep check.
+   * A persistent task nobody requested whose every dependant is in the
+   * tier starts only when one of them is demoted; once they have all
+   * finished it settles without an outcome, never spawned.
    * It still runs through `execute()` (so the logger frame is unchanged);
    * the orchestrator's execute reuses the up-front probe, so there is no
    * second cache.get. When undefined/empty, behavior is byte-identical.
@@ -463,6 +466,13 @@ export async function runGraph(options: ScheduleOptions): Promise<Map<string, Ta
   // they are exec-tier tasks, gated on their deps like any other.
   const demoted = new Set<string>()
   const inRestoreTier = (id: string): boolean => restoreTier?.has(id) === true && !demoted.has(id)
+  // A server pulled in only for restore-tier hits serves nobody: it waits
+  // (`dormant`) until a dependant is demoted, which starts it, or until
+  // every dependant has finished, which settles it unspawned. Settled
+  // without an outcome: it is not part of the run, as a pruned task is not.
+  const idle = idleServers(nodes, dependents, restoreTier)
+  const dormant = new Set<string>()
+  let settledIdle = 0
   const execReady = new ReadyHeap(priority)
   const restoreReady = new ReadyHeap(priority)
   // A restore-tier task is dep-independent (a stable hit's restore needs
@@ -580,6 +590,11 @@ export async function runGraph(options: ScheduleOptions): Promise<Map<string, Ta
     const finishOne = (id: string, outcome: TaskOutcome): void => {
       if (continueMode === 'never' && outcome.status === 'failed') failFastTripped = true
       outcomes.set(id, outcome)
+      // A dormant server is asked again: the dispatch settles it once its
+      // last dependant is in.
+      if (dormant.size > 0) {
+        for (const p of (nodes.get(id) as TaskNode).deps) if (dormant.delete(p)) execReady.push(p)
+      }
       // Observer hook (the logger's taskComplete). Crash-isolated: a
       // throwing observer must NOT break scheduling — it would otherwise
       // skip the dependent-enqueue + tick below and hang the run. Same
@@ -724,7 +739,7 @@ export async function runGraph(options: ScheduleOptions): Promise<Map<string, Ta
           while (execReady.size > 0) {
             const seq = execReady.peekSeq()
             const id = execReady.pop() as string
-            if (willSkip(id)) return id
+            if (willSkip(id) || idle.has(id)) return id
             if (exclusive?.has(id) === true) {
               if (!busy() && (!admitActive || admits(id))) return id
               parked.push([id, seq])
@@ -779,6 +794,14 @@ export async function runGraph(options: ScheduleOptions): Promise<Map<string, Ta
           })
           continue
         }
+        if (idle.has(id)) {
+          readyAt.delete(id)
+          if (dependents.get(id)!.every((d) => outcomes.has(d))) {
+            settledIdle++
+            release(id)
+          } else dormant.add(id)
+          continue
+        }
 
         const queuedMs = Date.now() - (readyAt.get(id) ?? Date.now())
         readyAt.delete(id)
@@ -847,6 +870,12 @@ export async function runGraph(options: ScheduleOptions): Promise<Map<string, Ta
               leave()
               untrack()
               demoted.add(id)
+              for (const p of node.deps) {
+                if (idle.delete(p) && dormant.delete(p)) {
+                  execReady.push(p)
+                  readyAt.set(p, Date.now())
+                }
+              }
               if (pending.get(id) === 0) {
                 execReady.push(id)
                 readyAt.set(id, Date.now())
@@ -919,7 +948,7 @@ export async function runGraph(options: ScheduleOptions): Promise<Map<string, Ta
       // takes none), so a task still holding one has no outcome yet, and
       // the lane counters could add nothing — deleting both from this
       // condition survived the whole core suite (item 644).
-      if (outcomes.size === nodes.size) {
+      if (outcomes.size + settledIdle === nodes.size) {
         resolved = true
         resolve(outcomes)
       }
@@ -928,3 +957,19 @@ export async function runGraph(options: ScheduleOptions): Promise<Map<string, Ta
     tick()
   })
 }
+
+/** Persistent tasks nobody asked for whose every dependant is a restore-tier hit. */
+function idleServers(
+  nodes: ReadonlyMap<string, TaskNode>,
+  dependents: ReadonlyMap<string, string[]>,
+  restoreTier: ReadonlySet<string> | undefined,
+): Set<string> {
+  const out = new Set<string>()
+  if (restoreTier === undefined || restoreTier.size === 0) return out
+  for (const n of nodes.values()) {
+    if (n.config.exec?.persistent === undefined || n.requested || n.surfaced === true) continue
+    const ds = dependents.get(n.id)
+    if (ds !== undefined && ds.every((d) => restoreTier.has(d))) out.add(n.id)
+  }
+  return out
+}

package/src/graph/task-graph.ts

@@ -929,6 +929,14 @@ function collideAcross(
           ;(files.outputsAddedToBy ??= []).push(...own)
           return
         }
+        // Already ordered: "make one depend on the other" would send the
+        // reader after an edge the config has. Name what keeps it out.
+        const outside = wsGlobs[own.indexOf(null)]!
+        throw new UserError(
+          `${head}. ${ws.id} depends on ${files.id}, but adding to its output needs every ` +
+            `cache.outputs.workspaceFiles entry inside ${rel === '' ? 'the workspace root' : rel}, ` +
+            `and ${JSON.stringify(outside)} is not. Give each task its own output path.`,
+        )
       }
       throw new UserError(
         `${head} and the run still reports success. Give each task its own output path` +

package/src/orchestrator/prepare.ts

@@ -357,12 +357,12 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
   const { projects, configured: projectsWithConfigs } = loaded
   mark('load configs')
 
-  // Boundary geometry considers every config-bearing project in the
-  // workspace, loaded or not — an out-of-scope nested project must
-  // still fence its files off from its parent's globs.
-  const nestedDirsByProject = computeNestedProjectDirs(
-    projectsWithConfigs.map((m) => ({ name: m.name, dir: m.dir })),
-  )
+  // Boundary geometry considers every workspace project, loaded or not,
+  // config or not: `--affected` gives a changed path to the deepest project
+  // dir, and a config-less one keys its files under its default `build`, so
+  // a parent's glob that folded (or cleaned) them crossed a boundary the
+  // selection drew (X-57).
+  const nestedDirsByProject = computeNestedProjectDirs(projectMetas)
 
   const candidateProjects = options.projects
     ? options.projects.filter((p) => projects.has(p))

package/src/orchestrator/projects.ts

@@ -155,8 +155,7 @@ export interface LoadedProjects {
   projects: Map<string, ProjectEntry>
   /**
    * Every project that can carry tasks: it has a config file, or a plugin
-   * fills the `project` stage and may give it tasks. Boundary geometry
-   * fences all of them, loaded or not.
+   * fills the `project` stage and may give it tasks.
    */
   configured: readonly ProjectMeta[]
 }
@@ -179,7 +178,7 @@ 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 seeds (or fences) a config-less
+  // `project` plugin a plain run never seeds 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

package/src/orchestrator/sandbox-request.ts

@@ -240,12 +240,18 @@ export async function sandboxRequestFor(
       ? [cacheDir]
       : []),
   ].map(toRealPath)
-  const config = wallOff(
-    resolveSandboxConfig(sandbox, node.projectDir, walls),
-    workspaceRoot,
-    walls,
-  )
+  const resolved = resolveSandboxConfig(sandbox, node.projectDir, walls)
+  // Made before the walls judge the binds: a directory grant naming nothing
+  // yet (`dist/`, `dist/**`) was judged as a file, its bind its parent, and
+  // a root project's was refused for `.git`.
   const placeholders = await prepareOutputsForBind(node.projectDir, sandbox.allow?.write ?? [])
+  let config: ResolvedSandboxConfig
+  try {
+    config = wallOff(resolved, workspaceRoot, walls)
+  } catch (err) {
+    await sweepPlaceholders(placeholders)
+    throw err
+  }
   const request: NonNullable<ExecuteRequest['sandbox']> = {
     // Only what the task declared, plus node_modules. Write paths are
     // readable too: a task that writes `dist/x` expects to read it back

package/src/workspace/migration.ts

@@ -50,9 +50,13 @@ export const PERSISTENT_TASK_NAMES: ReadonlySet<string> = new Set([
  * forwarded `--` args are appended to, and only the body takes them, as
  * npm appends them to the script and never to its hooks. A plain ` && `
  * join handed them to the post hook, and `test -f x && echo A; echo B` ran
- * `echo B` after a failed pre hook and went green (item 905). Each part
- * ends on its own line, so a trailing `# comment` cannot swallow the
- * paren. A script with no hooks is its body, verbatim.
+ * `echo B` after a failed pre hook and went green (item 905). npm appends
+ * them as TEXT: no part sees them as `$1`…, so the function quotes them
+ * into `vx_a`, clears its positional parameters, and evals the body with
+ * `vx_a` after it; `"$@"` on the body made a script's `$1` the first
+ * forwarded arg and its `$*` print them twice. Each part ends on its own
+ * line, so a trailing `# comment` cannot swallow the paren. A script with
+ * no hooks is its body, verbatim.
  */
 export function foldScriptHooks(
   pre: string | undefined,
@@ -60,14 +64,22 @@ export function foldScriptHooks(
   post: string | undefined,
 ): string {
   if (pre === undefined && post === undefined) return body
+  const quoted = `'${body.replaceAll("'", `'\\''`)}'`
   const parts = [
     ...(pre === undefined ? [] : [`(${pre}\n)`]),
-    `(${body} "$@"\n)`,
+    `(eval ${quoted}"$vx_a"\n)`,
     ...(post === undefined ? [] : [`(${post}\n)`]),
   ]
-  return `vx_script() {\n${parts.join(' && ')}\n}\nvx_script`
+  return `vx_script() {\n${QUOTE_ARGS}\nset --\n${parts.join(' && ')}\n}\nvx_script`
 }
 
+/** Each argument single-quoted into `vx_a`, in sh alone (no spawn per arg). */
+const QUOTE_ARGS =
+  `vx_q="'" vx_a=\n` +
+  `for vx_s in "$@"; do vx_r=; while :; do case $vx_s in *"$vx_q"*) ` +
+  `vx_r="$vx_r\${vx_s%%"$vx_q"*}'\\''"; vx_s=\${vx_s#*"$vx_q"};; *) break;; esac; done; ` +
+  `vx_a="$vx_a '$vx_r$vx_s'"; done`
+
 /**
  * Where a framework's build writes by default, for the cache TODO: the
  * hint said `dist/**` to every build, `next build` included, which writes