@vzn/vx 0.0.565 → 0.0.567

package/package.json

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

package/src/cli/watch-filter.ts

@@ -229,6 +229,7 @@ export function makeRootEventFilter(
   projectDirs: readonly string[],
   workspaceInputs: readonly string[],
   claimedRootFiles: ReadonlySet<string> = new Set(),
+  fenced: (ownDir: string, abs: string) => boolean = () => false,
 ): (filename: string) => boolean {
   const dirs = projectDirs.map((d) => path.resolve(d))
   const globs = workspaceInputs
@@ -257,12 +258,33 @@ export function makeRootEventFilter(
       return true
     }
     const abs = path.resolve(workspaceRoot, filename)
-    for (const d of dirs) if (abs === d || abs.startsWith(d + path.sep)) return true
+    for (const d of dirs)
+      if (abs === d || (abs.startsWith(d + path.sep) && !fenced(d, abs))) return true
     for (const g of globs) if (g.match(rel)) return true
     return false
   }
 }
 
+/**
+ * Whether `abs`, under the project at `ownDir`, lies inside another
+ * 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.
+ */
+export function makeFence(fenceDirs: readonly string[]): (ownDir: string, abs: string) => boolean {
+  const fences = fenceDirs.map((d) => path.resolve(d))
+  return (ownDir, abs) => {
+    const config = PROJECT_CONFIGS.has(path.basename(abs)) ? path.dirname(abs) : undefined
+    return fences.some(
+      (f) => f !== config && f.startsWith(ownDir + path.sep) && abs.startsWith(f + path.sep),
+    )
+  }
+}
+
 /**
  * A file whose edit can change what the loop watches: a `package.json`
  * (a dependency added under `--filter` widens the closure), a project

package/src/cli/watch-judge.ts

@@ -59,6 +59,8 @@ export interface JudgeContext {
   held(): boolean
   /** Projects whose uncached task may read a git-ignored file. */
   uncached(): ReadonlySet<string>
+  /** Whether `abs`, under the project at `ownDir`, lies in a project nested there (`makeFence`). */
+  fenced?(ownDir: string, abs: string): boolean
   /** The files git listed at the arm; absent when git could not answer. */
   existedAtArm?: ReadonlySet<string>
 }
@@ -176,10 +178,12 @@ export class ChangeJudge {
     // it reads what it likes, and its `.env.local` edit re-ran nothing
     // (item 947). Under such a project an ignored path is judged when the
     // user wrote it; one the last cycle wrote (the pid file an uncached
-    // task rewrites every run, the loop the filter exists for) stays out.
+    // task rewrites every run, the loop the filter exists for) stays out,
+    // as does one in a project nested under it, which it does not own.
     const editForUncached = (p: string): boolean =>
-      [...this.ctx.uncached()].some((dir) => p.startsWith(dir + path.sep)) &&
-      !this.writtenDuringLastCycle(p)
+      [...this.ctx.uncached()].some(
+        (dir) => p.startsWith(dir + path.sep) && this.ctx.fenced?.(dir, p) !== true,
+      ) && !this.writtenDuringLastCycle(p)
     // A path still there names the cycle before a gone one: an editor or
     // `sed -i` saving through a temporary file fires that file first, and
     // the cycle was announced by a name already renamed away.

package/src/cli/watch.ts

@@ -37,6 +37,7 @@ import {
   isWorkspaceConfigFile,
   gitFiles,
   isWorkspaceFingerprintFile,
+  makeFence,
   makeRootEventFilter,
   makeWatchIgnore,
   shapesWatchedSet,
@@ -242,6 +243,7 @@ export async function watchCmd(args: readonly string[]): Promise<number> {
     workspaceConfigImports: swept.workspaceConfigImports,
     memberBases: memberBaseDirs(workspace),
     packageDirs: new Set(allProjects.map((p) => p.dir)),
+    fenceDirs: fenceDirs(allProjects),
     // The workspace as the cycle that just ran saw it: a package added or
     // removed since the loop armed joins or leaves the watched set. The
     // scope is the one resolved at start; a new package joins it only as a
@@ -266,6 +268,7 @@ export async function watchCmd(args: readonly string[]): Promise<number> {
         configImports: sweep.configImports,
         workspaceConfigImports: sweep.workspaceConfigImports,
         packageDirs: new Set(all.map((p) => p.dir)),
+        fenceDirs: fenceDirs(all),
       }
     },
     // Under --frozen every cycle's configs are the lock's, so a re-lock is
@@ -312,10 +315,15 @@ 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. */
+  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)
+
 interface Rediscovered {
   projects: readonly ProjectMeta[]
   claimedRootFiles: ReadonlySet<string>
@@ -328,6 +336,7 @@ interface Rediscovered {
   configImports: readonly string[]
   workspaceConfigImports: readonly string[]
   packageDirs: ReadonlySet<string>
+  fenceDirs: readonly string[]
 }
 
 async function runWatchLoop(args: WatchLoopArgs): Promise<number> {
@@ -424,7 +433,14 @@ async function runWatchLoop(args: WatchLoopArgs): Promise<number> {
   // project would otherwise trigger every save during `bun install` —
   // and vx's own cache writes would trigger a cycle that writes again.
   let isIgnoredPath = makeWatchIgnore(cacheDir, outputs, inputs)
-  let matters = makeRootEventFilter(workspaceRoot, projectDirs, workspaceInputs, claimedRootFiles)
+  let fenced = makeFence(args.fenceDirs)
+  let matters = makeRootEventFilter(
+    workspaceRoot,
+    projectDirs,
+    workspaceInputs,
+    claimedRootFiles,
+    fenced,
+  )
   /** Since the last cycle, a member came or went, or a file that shapes the watched set changed (`shapesWatchedSet`). */
   let reread = false
 
@@ -446,6 +462,7 @@ async function runWatchLoop(args: WatchLoopArgs): Promise<number> {
     armedAt,
     held: () => held !== undefined,
     uncached: () => uncached,
+    fenced: (ownDir, abs) => fenced(ownDir, abs),
     ...(existedAtArm !== undefined ? { existedAtArm } : {}),
   })
   /** Per-project arms by directory, so `rearm` can add and drop them. */
@@ -472,9 +489,10 @@ async function runWatchLoop(args: WatchLoopArgs): Promise<number> {
   const armProject = (proj: ProjectMeta): void => {
     try {
       const handle = arm(proj.dir, true, (filename) => {
-        if (isIgnoredPath(proj.dir, filename)) return
+        const abs = path.join(proj.dir, filename)
+        if (isIgnoredPath(proj.dir, filename) || fenced(proj.dir, abs)) return
         if (shapesWatchedSet(filename)) reread = true
-        trigger(`${proj.name} ${filename}`, path.join(proj.dir, filename))
+        trigger(`${proj.name} ${filename}`, abs)
       })
       perProject.set(proj.dir, handle)
       armedAs.set(proj.dir, inodeOf(proj.dir) ?? '')
@@ -659,7 +677,14 @@ async function runWatchLoop(args: WatchLoopArgs): Promise<number> {
     memberBases = next.memberBases
     armBases()
     isIgnoredPath = makeWatchIgnore(cacheDir, outputs, inputs)
-    matters = makeRootEventFilter(workspaceRoot, projectDirs, workspaceInputs, claimedRootFiles)
+    fenced = makeFence(next.fenceDirs)
+    matters = makeRootEventFilter(
+      workspaceRoot,
+      projectDirs,
+      workspaceInputs,
+      claimedRootFiles,
+      fenced,
+    )
     if (next.workspaceWide !== workspaceWide) {
       // A task started or stopped declaring `workspaceFiles`: the other
       // arm's shape. Until item 891 the choice was made once, at start, and