@vzn/vx 0.0.64 → 0.0.66

package/package.json

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

package/src/cache/inputs.ts

@@ -495,11 +495,15 @@ export async function resolveOutputs(args: {
   nestedProjectDirs: string[]
 }): Promise<string[]> {
   if (args.outputs.length === 0) return []
-  const excludeGlobs = [
-    ...OUTPUT_NEVER,
-    ...boundaryIgnorePatterns(args.projectDir, args.nestedProjectDirs),
-  ].map(globFor)
-  const scanned = [...(await scanUnion(asTrees(args.outputs), excludeGlobs, args.projectDir))]
+  const excludeGlobs = OUTPUT_NEVER.map(globFor)
+  const scanned = [
+    ...(await scanUnion(
+      asTrees(args.outputs),
+      excludeGlobs,
+      args.projectDir,
+      inNestedProject(args.projectDir, args.nestedProjectDirs),
+    )),
+  ]
   // Containment, enforced HERE and not only at the loader. `cleanOutputs`
   // DELETES whatever this returns, and `Bun.Glob.scan` happily walks `..` out
   // of its cwd — so the loader's `..`/absolute rejection alone was a single
@@ -891,13 +895,10 @@ async function resolveFiles(args: ResolveFilesArgs): Promise<string[]> {
 
   if (positive.length === 0) return []
 
-  const boundaryIgnores = boundaryIgnorePatterns(args.projectDir, args.nestedProjectDirs)
-  const excludeGlobs = [
-    ...ALWAYS_IGNORE,
-    ...boundaryIgnores,
-    ...asTrees(args.ownOutputs),
-    ...asTrees(negative),
-  ].map(globFor)
+  const nested = inNestedProject(args.projectDir, args.nestedProjectDirs)
+  const excludeGlobs = [...ALWAYS_IGNORE, ...asTrees(args.ownOutputs), ...asTrees(negative)].map(
+    globFor,
+  )
 
   // Defer to git for the file set (Turbo / Nx parity). Nested .gitignore
   // files, .git/info/exclude, and global excludes all participate
@@ -910,7 +911,7 @@ async function resolveFiles(args: ResolveFilesArgs): Promise<string[]> {
   const positiveGlobs = asTrees(positive).map(globFor)
   // Everything below the snapshot that decides the result: the project, what
   // it declares, what it excludes as its own outputs, and the boundaries.
-  const memoKey = `${args.projectDir}\0${positive.join('\u0001')}\0${negative.join('\u0001')}\0${args.ownOutputs.join('\u0001')}\0${boundaryIgnores.join('\u0001')}`
+  const memoKey = `${args.projectDir}\0${positive.join('\u0001')}\0${negative.join('\u0001')}\0${args.ownOutputs.join('\u0001')}\0${args.nestedProjectDirs.join('\u0001')}`
   let gitFiles = args.gitFilesCache?.snapshotFor(args.projectDir, positiveGlobs)
   let undecodable = args.gitFilesCache?.undecodableNames
   if (gitFiles !== undefined) {
@@ -962,7 +963,7 @@ async function resolveFiles(args: ResolveFilesArgs): Promise<string[]> {
       }
     }
     if (!matched) continue
-    if (excludeGlobs.some((g) => g.match(rel))) continue
+    if (nested(rel) || excludeGlobs.some((g) => g.match(rel))) continue
     candidates.push(path.resolve(args.projectDir, rel))
   }
   if (unmatchedLiterals.size > 0) {
@@ -1061,6 +1062,7 @@ async function scanUnion(
   positive: readonly string[],
   excludeGlobs: readonly Bun.Glob[],
   cwd: string,
+  nested: (rel: string) => boolean = () => false,
 ): Promise<Set<string>> {
   const matches = new Set<string>()
   // `Bun.Glob`'s scan finds nothing for a brace whose alternatives hold a
@@ -1069,7 +1071,7 @@ async function scanUnion(
   for (const pattern of positive.flatMap(slashBraceExpansions)) {
     const glob = globFor(pattern)
     for (const rel of glob.scanSync({ cwd, onlyFiles: false, followSymlinks: false, dot: true })) {
-      if (excludeGlobs.some((g) => g.match(rel))) continue
+      if (nested(rel) || excludeGlobs.some((g) => g.match(rel))) continue
       const abs = path.resolve(cwd, rel)
       const st = lstatSync(abs, { throwIfNoEntry: false })
       if (st !== undefined && (st.isFile() || st.isSymbolicLink())) matches.add(abs)
@@ -1089,9 +1091,24 @@ function globFor(pattern: string): Bun.Glob {
   return g
 }
 
-function boundaryIgnorePatterns(projectDir: string, nestedDirs: string[]): string[] {
-  return nestedDirs.map((d) => {
-    const rel = path.relative(projectDir, d).split(path.sep).join('/')
-    return `${rel}/**`
-  })
+/**
+ * Whether a project-relative path lies inside a nested project: its
+ * ancestor directories looked up in a set, O(depth). One `<nested>/**` glob
+ * per nested project matched every file against every one, O(files ×
+ * nested): 320 ms of astro's 834 ms warm no-op, 4,003 files against 330
+ * fixture projects (I's log, A-11). A glob also read `*`, `?` or `{` in a
+ * nested directory's NAME as syntax, so a project at `pkg*` took its
+ * sibling `pkg-b`'s files out of the key; a name is a name.
+ */
+function inNestedProject(projectDir: string, nestedDirs: string[]): (rel: string) => boolean {
+  if (nestedDirs.length === 0) return () => false
+  const dirs = new Set(
+    nestedDirs.map((d) => path.relative(projectDir, d).split(path.sep).join('/')),
+  )
+  return (rel) => {
+    for (let i = rel.indexOf('/'); i !== -1; i = rel.indexOf('/', i + 1)) {
+      if (dirs.has(rel.slice(0, i))) return true
+    }
+    return false
+  }
 }

package/src/orchestrator/events.ts

@@ -68,7 +68,10 @@ export function createEventBus(): EventBus {
       // as wrong output, not a silent hang.
       for (const subscriber of subscribers) {
         try {
-          subscriber(event)
+          // A subscriber typed `void` may still be async: its rejection is
+          // isolated as its throw is.
+          const ret: unknown = subscriber(event)
+          if (ret instanceof Promise) ret.catch(() => {})
         } catch {
           // isolate: a surface fault can't propagate into the orchestrator
         }

package/src/orchestrator/plugin.ts

@@ -507,47 +507,53 @@ export async function installPlugins(args: InstallPluginsArgs): Promise<() => vo
         },
       },
       on(hook, handler) {
+        const fail = (err: unknown): void => {
+          if (disabled.has(plugin.name)) return
+          disabled.add(plugin.name)
+          warn(
+            `[vx] plugin '${plugin.name}' threw in ${hook}; disabled for this run: ${err instanceof Error ? err.message : String(err)}`,
+          )
+        }
         const dispose = bus.subscribe((event) => {
           if (disabled.has(plugin.name)) return
-          // void each handler call: hooks may return Promise; we
-          // intentionally don't await (the bus is synchronous;
-          // long-running plugin work happens off the critical path).
+          // Not awaited: the bus is synchronous and plugin work runs off the
+          // critical path. A handler's rejection is caught like its throw.
+          let ret: unknown
           try {
             switch (hook) {
               case 'onRunStart':
                 if (event.kind === 'run:start')
-                  void (handler as PluginHookHandlers['onRunStart'])(event.info)
+                  ret = (handler as PluginHookHandlers['onRunStart'])(event.info)
                 break
               case 'onTaskStart':
                 if (event.kind === 'task:start')
-                  void (handler as PluginHookHandlers['onTaskStart'])(event.node)
+                  ret = (handler as PluginHookHandlers['onTaskStart'])(event.node)
                 break
               case 'onTaskStdout':
                 if (event.kind === 'task:stdout')
-                  void (handler as PluginHookHandlers['onTaskStdout'])(event.node, event.chunk)
+                  ret = (handler as PluginHookHandlers['onTaskStdout'])(event.node, event.chunk)
                 break
               case 'onTaskStderr':
                 if (event.kind === 'task:stderr')
-                  void (handler as PluginHookHandlers['onTaskStderr'])(event.node, event.chunk)
+                  ret = (handler as PluginHookHandlers['onTaskStderr'])(event.node, event.chunk)
                 break
               case 'onTaskComplete':
                 if (event.kind === 'task:complete')
-                  void (handler as PluginHookHandlers['onTaskComplete'])(event.node, event.outcome)
+                  ret = (handler as PluginHookHandlers['onTaskComplete'])(event.node, event.outcome)
                 break
               case 'onRunStatus':
                 if (event.kind === 'run:status')
-                  void (handler as PluginHookHandlers['onRunStatus'])(event.line)
+                  ret = (handler as PluginHookHandlers['onRunStatus'])(event.line)
                 break
               case 'onRunEnd':
-                if (event.kind === 'run:end') void (handler as PluginHookHandlers['onRunEnd'])()
+                if (event.kind === 'run:end') ret = (handler as PluginHookHandlers['onRunEnd'])()
                 break
             }
           } catch (err) {
-            disabled.add(plugin.name)
-            warn(
-              `[vx] plugin '${plugin.name}' threw in ${hook}; disabled for this run: ${err instanceof Error ? err.message : String(err)}`,
-            )
+            fail(err)
+            return
           }
+          if (ret instanceof Promise) ret.catch(fail)
         })
         disposers.push(dispose)
       },