@vzn/vx 0.0.525 → 0.0.527

package/package.json

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

package/src/exec/runner.ts

@@ -158,13 +158,20 @@ function trailingCommentStart(command: string): number {
 /**
  * The command a task runs with the args after `--` appended, shell-quoted.
  * They go before a trailing comment: appended after it, `echo args: # show`
- * ran without them and said nothing (item 1060).
+ * ran without them and said nothing (item 1060). Trailing blanks go first.
  */
 export function withForwardArgs(command: string, args: readonly string[] | undefined): string {
   if (!args || args.length === 0) return command
   const quoted = args.map(shellQuote).join(' ')
   let comment = trailingCommentStart(command)
-  if (comment < 0) return `${command} ${quoted}`
+  if (comment < 0) {
+    // A command that ends in a newline (a template literal's closing line)
+    // ran the args as a command of their own: `--watch: not found`. Kept
+    // when an odd run of backslashes ends it: that escapes what follows.
+    const body = command.trimEnd()
+    const escaped = (/\\+$/.exec(body)?.[0].length ?? 0) % 2 === 1
+    return `${escaped ? command : body} ${quoted}`
+  }
   // A comment-only last line after a commented line: the args go before
   // the earliest comment, or they land inside it (`echo one # c\n# two`).
   for (let c = comment; c >= 0; c = trailingCommentStart(command.slice(0, c).trimEnd())) comment = c

package/src/orchestrator/plugin-host.ts

@@ -169,17 +169,21 @@ export async function applyProjectHooks(
  * deleting each other's outputs). A violation is reported
  * against the LAST plugin that ran: usually the one whose edit made it so,
  * but an earlier plugin's edit that a later one left in place is blamed on
- * the later one, since nothing is checked between plugins.
+ * the later one, since the structure is not checked between plugins.
+ * Each node's task config is (`afterEach`), like the `project` stage's.
  */
 export async function applyGraphHooks(
   plugins: readonly VxPlugin[],
   nodes: Map<string, TaskNode>,
   ctx: GraphHookContext,
+  /** Runs after EACH plugin's edit, so a refused task config names the plugin that wrote it. */
+  afterEach?: (plugin: VxPlugin) => void,
 ): Promise<void> {
   let last: VxPlugin | undefined
   for (const plugin of plugins) {
     if (plugin.graph === undefined) continue
     await safe(plugin, 'graph', () => plugin.graph!(nodes, ctx))
+    afterEach?.(plugin)
     last = plugin
   }
   if (last === undefined) return

package/src/orchestrator/prepare.ts

@@ -39,6 +39,7 @@ import {
   resolveCacheDir,
   resolveStoreRoot,
   type ProjectEntry,
+  validateProjectConfig,
 } from '../workspace/index.js'
 import {
   buildTaskGraph,
@@ -61,6 +62,7 @@ import {
   discoverProjects,
   gitOfDiscovery,
   graphOfDiscovery,
+  isDefaultBuild,
   loadProjects,
   loadWorkspacePlugins,
   type LoadedProjects,
@@ -597,12 +599,30 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
     )
     mark('git enumeration')
     if (hasHook(plugins, 'graph')) {
-      await applyGraphHooks(plugins, nodes, {
-        workspaceRoot,
-        cacheDir,
-        warn: (m) => log.status(m),
-        requested: [...nodes.values()].filter((n) => n.requested).map((n) => n.id),
-      })
+      // A hook edits each node's config in place, as `project` does, so the
+      // edit is held to what the loader accepts from a user: a misspelled
+      // `exec` field ran as an empty command and failed with no reason.
+      const configPaths = new Map(projectMetas.map((m) => [m.name, m.configPath]))
+      await applyGraphHooks(
+        plugins,
+        nodes,
+        {
+          workspaceRoot,
+          cacheDir,
+          warn: (m) => log.status(m),
+          requested: [...nodes.values()].filter((n) => n.requested).map((n) => n.id),
+        },
+        (plugin) => {
+          for (const n of nodes.values()) {
+            if (isDefaultBuild(n.config)) continue
+            const where = configPaths.get(n.projectName) ?? `${n.projectName} (no config file)`
+            validateProjectConfig(
+              { tasks: { [n.taskName]: n.config } },
+              `${where} (after plugin '${plugin.name}')`,
+            )
+          }
+        },
+      )
     }
     if (hasHook(plugins, 'key')) {
       await applyKeyHooks(plugins, nodes, { workspaceRoot, cacheDir, warn: (m) => log.status(m) })

package/src/workspace/workspace.ts

@@ -74,7 +74,9 @@ const decoder = new TextDecoder()
  * `^task` edges vanish, upstream hashes drop out of the cache key (stale
  * hits), and a second cache dir appears under the member. Claiming is decided
  * with the same globs `loadWorkspace` applies, so "the root that claims me"
- * and "the root that lists me as a project" cannot diverge.
+ * and "the root that lists me as a project" cannot diverge. An outer root
+ * that lists both the claimer and the claimed member outranks the claimer:
+ * from the claimer's own directory the walk reaches the outer root too.
  *
  * When no candidate claims `start` — a standalone package, or a subdirectory
  * of a single-project repo — the nearest candidate wins (the root itself IS
@@ -92,6 +94,9 @@ export async function findWorkspaceRoot(
   // The nearest manifest with workspace globs of its own, once passed: an
   // outer root claims the tree only by listing this directory itself.
   let inner: string | null = null
+  // The root that claims `start`, and the members it claimed it through.
+  let claimed: string | null = null
+  let members: string[] = []
   while (true) {
     let globs: string[] | null
     try {
@@ -105,12 +110,23 @@ export async function findWorkspaceRoot(
     }
     if (globs !== null) {
       nearest ??= dir
-      if (claimsMember(dir, inner === null ? below : [inner], globs)) return dir
+      if (claimed !== null) {
+        // An outer root that lists both the claimer and the member owns
+        // them: `packages/**` holding `packages/inner` (with `workspaces:
+        // ['sub']`) and `packages/inner/sub` resolved `sub` to `inner` and
+        // `inner` to the outer root, two roots and two keys for one tree.
+        if (claimsMember(dir, [claimed], globs) && claimsMember(dir, members, globs)) claimed = dir
+      } else if (claimsMember(dir, inner === null ? below : [inner], globs)) {
+        claimed = dir
+        members = inner === null ? [...below] : [inner]
+      }
       // pnpm takes the nearest `pnpm-workspace.yaml` as the root, listed or
       // not. Walking past it, `apps/inner` resolved to the outer workspace
       // while `apps/inner/pkgs/x` resolved to the inner one: two roots and
       // two caches for one tree (item 990). Already read: `reads` holds it.
-      if ((await readOnce(reads, path.join(dir, 'pnpm-workspace.yaml'))) !== null) return dir
+      if ((await readOnce(reads, path.join(dir, 'pnpm-workspace.yaml'))) !== null) {
+        return claimed ?? dir
+      }
     }
     const parent = path.dirname(dir)
     if (parent === dir) break
@@ -126,6 +142,7 @@ export async function findWorkspaceRoot(
     if (inner === null && globs !== null && globs.length > 0) inner = dir
     dir = parent
   }
+  if (claimed !== null) return claimed
   if (nearest !== null) return nearest
   throw new UserError(
     `Could not find a workspace root in any parent of ${start} ` +