@vzn/vx 0.0.524 → 0.0.526

package/package.json

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

package/src/cache/inputs.ts

@@ -21,6 +21,7 @@ import { lstatSync, readdirSync, realpathSync, rmdirSync, rmSync } from 'node:fs
 import { rm, rmdir } from 'node:fs/promises'
 import type { CacheConfig, CacheInputs } from '../config.js'
 import {
+  anyTaskGlob,
   asTrees,
   isExecutableMissing,
   isLiteralPattern,
@@ -249,10 +250,10 @@ async function resolveWorkspaceFiles(args: {
   }
   if (positive.length === 0) return []
 
-  const excludeGlobs = [...ALWAYS_IGNORE, ...asTrees(negative)].map(globFor)
+  const isExcluded = anyTaskGlob([...ALWAYS_IGNORE, ...asTrees(negative)])
   // A path the task's own outputs take back with `!` is no output, so it
   // stays an input (A-44).
-  const ownOutput = outputMatcher(args.ownWorkspaceOutputs, globFor)
+  const ownOutput = outputMatcher(args.ownWorkspaceOutputs)
   const positiveGlobs = asTrees(positive).map(globFor)
   // Workspace-wide partition, keyed by the workspace root. Populated
   // up-front by `populateGitFilesCache(..., workspaceWide: true)` when
@@ -281,8 +282,8 @@ async function resolveWorkspaceFiles(args: {
     args,
     gitFiles,
     positive,
-    positiveGlobs,
-    (rel) => excludeGlobs.some((g) => g.match(rel)) || ownOutput(rel),
+    anyTaskGlob(asTrees(positive)),
+    (rel) => isExcluded(rel) || ownOutput(rel),
     undecodable,
   )
   if (memoKey !== undefined) args.memo!.set(memoKey, { snapshot: gitFiles, result })
@@ -293,7 +294,7 @@ async function resolveWorkspaceFilesOver(
   args: { workspaceRoot: string; gitFilesCache?: GitFilesCache },
   gitFiles: readonly string[],
   positive: readonly string[],
-  positiveGlobs: readonly Bun.Glob[],
+  isPositive: (rel: string) => boolean,
   excluded: (rel: string) => boolean,
   undecodable: ReadonlySet<string> | undefined,
 ): Promise<string[]> {
@@ -301,13 +302,13 @@ async function resolveWorkspaceFilesOver(
   // carries its own copy of the filter-over-git-set design, so the same
   // silently-folds-nothing hazard exists here — and a fix applied only to the
   // project half would pass that half's tests while leaving this one live.
-  const unmatchedLiterals = new Set(
+  const unmatchedLiterals = unanswered(
     positive.map(normalizeGlob).filter(isLiteralPattern).map(stripTrailingSlash),
+    gitFiles,
   )
   const candidates: string[] = []
   for (const rel of gitFiles) {
-    if (unmatchedLiterals.size > 0) settleLiterals(unmatchedLiterals, rel)
-    if (!positiveGlobs.some((g) => g.match(rel))) continue
+    if (!isPositive(rel)) continue
     if (excluded(rel)) continue
     candidates.push(path.resolve(args.workspaceRoot, rel))
   }
@@ -935,11 +936,37 @@ function stripTrailingSlash(p: string): string {
 // unchanged.
 export { asTrees } from '../util/index.js'
 
-/** A literal is answered by the path itself or by anything under it. */
-function settleLiterals(unmatched: Set<string>, rel: string): void {
-  for (const lit of unmatched) {
-    if (rel === lit || rel.startsWith(`${lit}/`)) unmatched.delete(lit)
+/**
+ * The literals no path in `files` answers; a literal is answered by the
+ * path itself or by anything under it. Git lists in order, so a binary
+ * search finds the answer; a listing out of code-unit order (git sorts
+ * bytes) can hide one from it, so only a walk says a literal is
+ * unanswered. Testing every literal against every file was ~1.5 ms of a
+ * 1,800-file all-cached run (2026-10-06).
+ */
+function unanswered(literals: readonly string[], files: readonly string[]): Set<string> {
+  const left = new Set<string>()
+  for (const lit of literals) {
+    const under = `${lit}/`
+    const answered =
+      files[lowerBound(files, lit)] === lit ||
+      files[lowerBound(files, under)]?.startsWith(under) === true ||
+      files.some((rel) => rel === lit || rel.startsWith(under))
+    if (!answered) left.add(lit)
   }
+  return left
+}
+
+/** The first index whose path is not below `key`. */
+function lowerBound(files: readonly string[], key: string): number {
+  let lo = 0
+  let hi = files.length
+  while (lo < hi) {
+    const mid = (lo + hi) >>> 1
+    if (files[mid]! < key) lo = mid + 1
+    else hi = mid
+  }
+  return lo
 }
 
 /**
@@ -1065,10 +1092,11 @@ function refuseOneAlternativeBrace(
 interface FilesPlan {
   positive: string[]
   negative: string[]
-  excludeGlobs: Bun.Glob[]
+  isExcluded: (rel: string) => boolean
   ownOutput: (rel: string) => boolean
   positiveGlobs: Bun.Glob[]
-  /** The literal entries, each naming one path (see `unmatchedLiterals`). */
+  isPositive: (rel: string) => boolean
+  /** The literal entries, each naming one path (see `unanswered`). */
   literals: string[]
   /**
    * Whether a project-relative path is an input by the declaration alone:
@@ -1112,11 +1140,12 @@ function filesPlan(
       : {
           positive,
           negative,
-          excludeGlobs: [...ALWAYS_IGNORE, ...asTrees(negative)].map(globFor),
+          isExcluded: anyTaskGlob([...ALWAYS_IGNORE, ...asTrees(negative)]),
           // A path the task's own outputs take back with `!` is no output, so it
           // stays an input: a tracked file under `dist` the build reads (A-44).
-          ownOutput: outputMatcher(ownOutputs, globFor),
+          ownOutput: outputMatcher(ownOutputs),
           positiveGlobs: asTrees(positive).map(globFor),
+          isPositive: anyTaskGlob(asTrees(positive)),
           literals: positive.map(normalizeGlob).filter(isLiteralPattern).map(stripTrailingSlash),
           verdicts: new Map<string, boolean>(),
         }
@@ -1149,10 +1178,7 @@ export function declaresInput(
 function inPlan(plan: FilesPlan, rel: string): boolean {
   let input = plan.verdicts.get(rel)
   if (input === undefined) {
-    input =
-      plan.positiveGlobs.some((g) => g.match(rel)) &&
-      !plan.excludeGlobs.some((g) => g.match(rel)) &&
-      !plan.ownOutput(rel)
+    input = plan.isPositive(rel) && !plan.isExcluded(rel) && !plan.ownOutput(rel)
     plan.verdicts.set(rel, input)
   }
   return input
@@ -1168,13 +1194,10 @@ function workspaceMatcher(
   let m = workspaceMatchers.get(key)
   if (m !== undefined) return m
   const { positive, negative } = splitNegations(decl)
-  const positiveGlobs = asTrees(positive).map(globFor)
-  const excludeGlobs = [...ALWAYS_IGNORE, ...asTrees(negative)].map(globFor)
-  const ownOutput = outputMatcher(ownOutputs, globFor)
-  m = (rel) =>
-    positiveGlobs.some((g) => g.match(rel)) &&
-    !excludeGlobs.some((g) => g.match(rel)) &&
-    !ownOutput(rel)
+  const isPositive = anyTaskGlob(asTrees(positive))
+  const isExcluded = anyTaskGlob([...ALWAYS_IGNORE, ...asTrees(negative)])
+  const ownOutput = outputMatcher(ownOutputs)
+  m = (rel) => isPositive(rel) && !isExcluded(rel) && !ownOutput(rel)
   workspaceMatchers.set(key, m)
   return m
 }
@@ -1182,7 +1205,7 @@ function workspaceMatcher(
 async function resolveFiles(args: ResolveFilesArgs): Promise<string[]> {
   const plan = filesPlan(args.files, args.ownOutputs)
   if (plan === null) return []
-  const { positive, negative, excludeGlobs, ownOutput, positiveGlobs } = plan
+  const { positive, negative, isExcluded, ownOutput, positiveGlobs, isPositive } = plan
 
   const nested = inNestedProject(args.projectDir, args.nestedProjectDirs)
 
@@ -1233,7 +1256,6 @@ async function resolveFiles(args: ResolveFilesArgs): Promise<string[]> {
   // an artifact built from an older version of a file the config explicitly
   // claims as an input. See the refusal below for why this is not simply
   // honoured instead.
-  const unmatchedLiterals = new Set(plan.literals)
   // First pass: glob-filter to candidate absolute paths (no I/O). Git
   // prints normalized relative paths, so under an absolute, normalized
   // project dir a join is a concatenation: `path.resolve` per file was
@@ -1249,18 +1271,15 @@ async function resolveFiles(args: ResolveFilesArgs): Promise<string[]> {
   const candidates: string[] = []
   const verdicts = plan.verdicts
   for (const rel of gitFiles) {
-    if (unmatchedLiterals.size > 0) settleLiterals(unmatchedLiterals, rel)
     let input = verdicts.get(rel)
     if (input === undefined) {
-      input =
-        positiveGlobs.some((g) => g.match(rel)) &&
-        !excludeGlobs.some((g) => g.match(rel)) &&
-        !ownOutput(rel)
+      input = isPositive(rel) && !isExcluded(rel) && !ownOutput(rel)
       verdicts.set(rel, input)
     }
     if (!input || nested(rel)) continue
     candidates.push(base === undefined ? path.resolve(args.projectDir, rel) : base + rel)
   }
+  const unmatchedLiterals = unanswered(plan.literals, gitFiles)
   if (unmatchedLiterals.size > 0) {
     await assertNoInvisibleLiteralInputs(unmatchedLiterals, args.projectDir, 'files')
   }

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/util/index.ts

@@ -42,6 +42,7 @@ export {
   relPosix,
   splitNegations,
   staticPrefix,
+  anyTaskGlob,
   taskGlob,
   wholeSubtreePrefixes,
   slashBraceExpansions,

package/src/util/paths.ts

@@ -196,8 +196,69 @@ export const EXTGLOB = /[!@+*?]\(/
  */
 export function taskGlob(pattern: string): Bun.Glob {
   // A `]` with no `[` before it is already literal to `Bun.Glob`.
-  if (!pattern.includes('[')) return new Bun.Glob(pattern)
-  return new Bun.Glob(pattern.replace(/(?<!\\)[[\]]/g, '\\$&'))
+  const source = pattern.includes('[') ? pattern.replace(/(?<!\\)[[\]]/g, '\\$&') : pattern
+  const glob = new Bun.Glob(source)
+  const re = regExpSource(pattern)
+  if (re === null) return glob
+  const compiled = new RegExp(`^${re}$`, 'u')
+  const native = Object.getPrototypeOf(glob) as Bun.Glob
+  // A path with a slash on the end names no file vx lists; `Bun.Glob` reads
+  // it by rules of its own (`src/**` takes `src/`, never `src`). `scan`
+  // stays `Bun.Glob`'s. Set on the instance, not by a subclass, so the glob
+  // is built by whatever `Bun.Glob` is at the call (the playground's port).
+  glob.match = (rel: string): boolean =>
+    rel.endsWith('/') ? native.match.call(glob, rel) : compiled.test(rel)
+  return glob
+}
+
+/**
+ * Whether a path matches any of `patterns`, each a task glob: one compiled
+ * RegExp for the lot when every pattern has one, else a glob each. An input
+ * file was matched against a dozen globs (its positives, the always-ignored
+ * list, its negatives) one native call at a time.
+ */
+export function anyTaskGlob(patterns: readonly string[]): (rel: string) => boolean {
+  if (patterns.length === 0) return () => false
+  const sources = patterns.map(regExpSource)
+  const globs = patterns.map(taskGlob)
+  if (sources.every((r) => r !== null)) {
+    const re = new RegExp(`^(?:${sources.join('|')})$`, 'u')
+    return (rel) => (rel.endsWith('/') ? globs.some((g) => g.match(rel)) : re.test(rel))
+  }
+  return (rel) => globs.some((g) => g.match(rel))
+}
+
+const REGEXP_SYNTAX = /[\\^$.*+?()[\]{}|]/g
+
+/**
+ * The RegExp source of a task glob, matching what `Bun.Glob` matches
+ * (`tests/util-paths.test.ts` holds the two to the same verdict on every
+ * shape): `*` any run within a name, `?` one character, a `**` segment any
+ * number of directories, a bracket itself. Null for the syntax left to
+ * `Bun.Glob`: a brace, an escape, a leading `!`, an empty, `.` or `..`
+ * segment, a `**` inside a name, or two `**` segments in a row.
+ */
+function regExpSource(pattern: string): string | null {
+  if (/[\\{}]/.test(pattern) || pattern.startsWith('!')) return null
+  const segments = pattern.split('/')
+  let out = ''
+  for (let i = 0; i < segments.length; i++) {
+    const seg = segments[i]!
+    const last = i === segments.length - 1
+    if (seg === '**') {
+      if (segments[i - 1] === '**') return null
+      // A globstar is zero or more whole directories; at the end, one or
+      // more names (`src/**` does not match `src`).
+      if (segments.length === 1) out += '[^]*'
+      else if (last) out += '/[^]+'
+      else out += i === 0 ? '(?:[^]*/)?' : '/(?:[^]*/)?'
+      continue
+    }
+    if (seg === '' || seg === '.' || seg === '..' || seg.includes('**')) return null
+    if (i > 0 && segments[i - 1] !== '**') out += '/'
+    out += seg.replace(REGEXP_SYNTAX, (c) => (c === '*' ? '[^/]*' : c === '?' ? '[^/]' : `\\${c}`))
+  }
+  return out
 }
 
 function stripTrailingSlash(p: string): string {
@@ -263,15 +324,12 @@ export function splitNegations(globs: readonly string[]): {
  * matcher as-is would be `Bun.Glob`'s own negation, true of every OTHER
  * path (A-44).
  */
-export function outputMatcher(
-  globs: readonly string[],
-  compile: (pattern: string) => Bun.Glob = taskGlob,
-): (rel: string) => boolean {
+export function outputMatcher(globs: readonly string[]): (rel: string) => boolean {
   const { positive, negative } = splitNegations(globs)
   if (positive.length === 0) return () => false
-  const pos = asTrees(positive).map(compile)
-  const neg = asTrees(negative).map(compile)
-  return (rel) => pos.some((g) => g.match(rel)) && !neg.some((g) => g.match(rel))
+  const pos = anyTaskGlob(asTrees(positive))
+  const neg = anyTaskGlob(asTrees(negative))
+  return (rel) => pos(rel) && !neg(rel)
 }
 
 /**