@vzn/vx 0.0.341 → 0.0.342

package/README.md

@@ -100,7 +100,7 @@ key by key: [Turbo and Nx config support](https://vznjs.github.io/vx/compare/tur
 ## Install
 
 ```sh
-npm install -D @vzn/vx     # or: pnpm add -D · yarn add -D · bun add -d
+npm install -D @vzn/vx     # or: pnpm add -D -w · yarn add -D (-W on Yarn 1) · bun add -d
 ```
 
 The package ships a prebuilt binary for Linux and macOS, x64 and arm64

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vzn/vx",
-  "version": "0.0.341",
+  "version": "0.0.342",
   "description": "A fast, correct task runner and build cache for JavaScript monorepos.",
   "type": "module",
   "exports": {
@@ -21,10 +21,10 @@
     "node": ">=18"
   },
   "optionalDependencies": {
-    "@vzn/vx-linux-x64": "0.0.341",
-    "@vzn/vx-linux-arm64": "0.0.341",
-    "@vzn/vx-darwin-x64": "0.0.341",
-    "@vzn/vx-darwin-arm64": "0.0.341"
+    "@vzn/vx-linux-x64": "0.0.342",
+    "@vzn/vx-linux-arm64": "0.0.342",
+    "@vzn/vx-darwin-x64": "0.0.342",
+    "@vzn/vx-darwin-arm64": "0.0.342"
   },
   "dependencies": {
     "@anthropic-ai/sandbox-runtime": "^0.0.76"

package/src/exec/runner.ts

@@ -784,6 +784,8 @@ export function droppedOutputLine(dropped: number): string {
   )
 }
 
+const isHighSurrogate = (code: number): boolean => code >= 0xd800 && code <= 0xdbff
+
 /**
  * A head-and-tail accumulator: the head fills once, the tail is a ring
  * of chunks trimmed from the front, so memory is bounded by the two
@@ -797,11 +799,14 @@ class BoundedCapture {
 
   push(chunk: string): void {
     if (this.head.length < CAPTURE_HEAD_CHARS) {
-      const room = CAPTURE_HEAD_CHARS - this.head.length
+      let room = CAPTURE_HEAD_CHARS - this.head.length
       if (chunk.length <= room) {
         this.head += chunk
         return
       }
+      // Never between a surrogate pair's halves: the bounds count UTF-16
+      // units, and a halved character read U+FFFD in the replay.
+      if (isHighSurrogate(chunk.charCodeAt(room - 1))) room--
       this.head += chunk.slice(0, room)
       chunk = chunk.slice(room)
     }
@@ -815,9 +820,10 @@ class BoundedCapture {
         this.tailLen -= first.length
         this.dropped += first.length
       } else {
-        this.tail[0] = first.slice(excess)
-        this.tailLen -= excess
-        this.dropped += excess
+        const cut = isHighSurrogate(first.charCodeAt(excess - 1)) ? excess + 1 : excess
+        this.tail[0] = first.slice(cut)
+        this.tailLen -= cut
+        this.dropped += cut
       }
     }
   }

package/src/orchestrator/hit-restore.ts

@@ -61,7 +61,7 @@ export async function restoreHit(restore: RestoreHitArgs): Promise<TaskOutcome>
   // The directories the positive globs cover whole. A `!` entry inside one
   // leaves the snapshot sound: a file added or removed there still bumps a
   // recorded directory, and the walk that follows applies the `!` (A-46).
-  const dirPrefixes = wholeSubtreePrefixes(splitNegations(outputs).positive)
+  const dirPrefixes = dirPrefixesOf(outputs)
   const cleanArgs = {
     projectDir: node.projectDir,
     outputs,
@@ -133,52 +133,54 @@ export async function restoreHit(restore: RestoreHitArgs): Promise<TaskOutcome>
         setKnown = covers && (await args.cache.outputDirsCurrent!(node.projectDir, dirRows))
         endDirs()
       }
-      let actualAbs: string[]
-      let actualWsAbs: string[]
+      let treeMatches: boolean
       if (setKnown) {
-        actualAbs = projExpected.map((e) => path.join(node.projectDir, e.path))
-        actualWsAbs = []
+        // The snapshot proved the tree holds exactly the entry's project
+        // rows (one per path, the table's key) and no workspace output is
+        // declared, so the comparisons below hold by construction: mapping
+        // each row to a path and back was ~5 ms per 1,000 warm hits.
+        treeMatches = wsExpected.length === 0
       } else {
         const endGlob = span('output glob')
-        actualAbs = await resolveOutputs({
+        const actualAbs = await resolveOutputs({
           projectDir: node.projectDir,
           outputs,
           nestedProjectDirs: args.nestedProjectDirs,
         })
-        actualWsAbs = await resolveWorkspaceOutputs({
+        const actualWsAbs = await resolveWorkspaceOutputs({
           workspaceRoot: args.workspaceRoot,
           outputs: wsOutputs,
         })
         endGlob()
+        const setsMatch = (
+          actual: readonly string[],
+          exp: ReadonlyArray<{ path: string }>,
+        ): boolean => {
+          const expSet = new Set(exp.map((e) => e.path))
+          return actual.length === expSet.size && actual.every((r) => expSet.has(r))
+        }
+        // A stray a dependant's glob could have added is not a stray; a path
+        // this entry recorded is never dropped, even where that glob covers
+        // the whole tree (strapi's shape: both on `dist`).
+        const expectedRels = new Set(projExpected.map((e) => e.path))
+        const expectedWsRels = new Set(wsExpected.map((e) => e.path))
+        const actualRels = actualAbs
+          .map((p) => path.relative(node.projectDir, p).split(path.sep).join('/'))
+          .filter((rel) => expectedRels.has(rel) || !isAddition(rel))
+        const actualWsRels = actualWsAbs
+          .map((p) => path.relative(args.workspaceRoot, p).split(path.sep).join('/'))
+          .filter((rel) => expectedWsRels.has(rel) || !isAddition(rel))
+        const rowsPresent = (
+          actual: readonly string[],
+          exp: ReadonlyArray<{ path: string }>,
+        ): boolean => {
+          const have = new Set(actual)
+          return exp.every((e) => have.has(e.path))
+        }
+        treeMatches = additive
+          ? rowsPresent(actualRels, projExpected) && rowsPresent(actualWsRels, wsExpected)
+          : setsMatch(actualRels, projExpected) && setsMatch(actualWsRels, wsExpected)
       }
-      const setsMatch = (
-        actual: readonly string[],
-        exp: ReadonlyArray<{ path: string }>,
-      ): boolean => {
-        const expSet = new Set(exp.map((e) => e.path))
-        return actual.length === expSet.size && actual.every((r) => expSet.has(r))
-      }
-      // A stray a dependant's glob could have added is not a stray; a path
-      // this entry recorded is never dropped, even where that glob covers
-      // the whole tree (strapi's shape: both on `dist`).
-      const expectedRels = new Set(projExpected.map((e) => e.path))
-      const expectedWsRels = new Set(wsExpected.map((e) => e.path))
-      const actualRels = actualAbs
-        .map((p) => path.relative(node.projectDir, p).split(path.sep).join('/'))
-        .filter((rel) => expectedRels.has(rel) || !isAddition(rel))
-      const actualWsRels = actualWsAbs
-        .map((p) => path.relative(args.workspaceRoot, p).split(path.sep).join('/'))
-        .filter((rel) => expectedWsRels.has(rel) || !isAddition(rel))
-      const rowsPresent = (
-        actual: readonly string[],
-        exp: ReadonlyArray<{ path: string }>,
-      ): boolean => {
-        const have = new Set(actual)
-        return exp.every((e) => have.has(e.path))
-      }
-      const treeMatches = additive
-        ? rowsPresent(actualRels, projExpected) && rowsPresent(actualWsRels, wsExpected)
-        : setsMatch(actualRels, projExpected) && setsMatch(actualWsRels, wsExpected)
       if (treeMatches) {
         const endStat = span('output stat')
         skipRestore =
@@ -307,3 +309,21 @@ export async function restoreHit(restore: RestoreHitArgs): Promise<TaskOutcome>
     wallclockEndNs: process.hrtime.bigint() - args.runStartHrTimeNs,
   }
 }
+
+/**
+ * The whole-subtree directories of a task's output globs, memoised by the
+ * list: a function of the declared globs alone, and a workspace declares a
+ * handful of output lists over thousands of tasks (~5 ms of a 1,000-hit
+ * warm run, unmemoised). Callers only read the result.
+ */
+function dirPrefixesOf(outputs: readonly string[]): readonly string[] | null {
+  const key = JSON.stringify(outputs)
+  let prefixes = prefixMemo.get(key)
+  if (prefixes === undefined) {
+    prefixes = wholeSubtreePrefixes(splitNegations(outputs).positive)
+    prefixMemo.set(key, prefixes)
+  }
+  return prefixes
+}
+
+const prefixMemo = new Map<string, readonly string[] | null>()

package/src/orchestrator/run.ts

@@ -219,12 +219,29 @@ export async function run(options: RunOptions): Promise<RunSummary> {
   // it twice (item 635). Otherwise a fresh internal bus.
   const bus = options.bus ?? createEventBus()
   const unsubscribeTerminal = bus.subscribe(terminalSubscriber(sink))
-  try {
-    return await runOnBus(options, bus, colors, () => terminal?.failureRecap() ?? [])
-  } finally {
+  const detach = (): void => {
     unsubscribeTerminal()
     terminal?.settle()
   }
+  let held = false
+  try {
+    const summary = await runOnBus(options, bus, colors, () => terminal?.failureRecap() ?? [])
+    if (summary.persistent === undefined) return summary
+    // Servers handed back still running still write: `vx watch dev` printed
+    // none of its server's log while it idled, the renderer gone with this
+    // return (C-57). It stays until the caller stops them.
+    held = true
+    const { stop } = summary.persistent
+    return {
+      ...summary,
+      persistent: {
+        ...summary.persistent,
+        stop: (signal) => stop(signal).finally(detach),
+      },
+    }
+  } finally {
+    if (!held) detach()
+  }
 }
 
 async function runOnBus(

package/src/orchestrator/summary.ts

@@ -419,9 +419,12 @@ export function formatSkippedSection(outcomes: readonly TaskOutcome[]): string[]
     list.push(o.node.id)
     groups.set(cause, list)
   }
+  // "Blocked upstream" only when every skip was: a fail-fast skip had no
+  // blocker, and the header claimed one over its own cause line (C-55).
+  const blocked = skipped.every((o) => o.blockedBy !== undefined) ? ' \u2014 blocked upstream' : ''
   const lines = [
     '',
-    `  Skipped:  ${skipped.length} task${skipped.length === 1 ? '' : 's'} never started \u2014 blocked upstream`,
+    `  Skipped:  ${skipped.length} task${skipped.length === 1 ? '' : 's'} never started${blocked}`,
   ]
   const NAMES = 8
   for (const [cause, ids] of [...groups].sort((a, b) => b[1].length - a[1].length)) {

package/src/workspace/filter.ts

@@ -49,6 +49,8 @@ export interface ParsedFilter {
   sinceViaDeps?: true
   /** A path form carrying a glob (`./packages/*`): matched over the root-relative project dir. */
   pathGlob?: Bun.Glob
+  /** `./a/**`'s `a`: a trailing `**` matches zero dirs, and `Bun.Glob` does not (D-84). */
+  pathGlobBase?: Bun.Glob
   /** The workspace root `pathGlob` is relative to. */
   pathRoot?: string
   /** `//`: the project at `matcher` itself, never the ones under it. */
@@ -142,6 +144,7 @@ export function parseFilter(raw: string, workspaceRoot: string): ParsedFilter {
   let isPath = false
   let matcher = s
   let pathGlob: Bun.Glob | undefined
+  let pathGlobBase: Bun.Glob | undefined
   const pathForm =
     s.startsWith('./') || s === '.'
       ? s
@@ -157,7 +160,9 @@ export function parseFilter(raw: string, workspaceRoot: string): ParsedFilter {
     // A member glob, not a task glob: `Bun.Glob`'s alphabet, the class included.
     if (BUN_GLOB_WILDCARDS.test(pathForm)) {
       const rel = path.relative(workspaceRoot, matcher).split(path.sep).join('/')
-      pathGlob = new Bun.Glob(rel.replace(/\/+$/, ''))
+      const glob = rel.replace(/\/+$/, '')
+      pathGlob = new Bun.Glob(glob)
+      if (glob.endsWith('/**')) pathGlobBase = new Bun.Glob(glob.slice(0, -3))
     }
   }
 
@@ -171,6 +176,7 @@ export function parseFilter(raw: string, workspaceRoot: string): ParsedFilter {
     isPath,
     matcher,
     ...(pathGlob !== undefined ? { pathGlob, pathRoot: workspaceRoot } : {}),
+    ...(pathGlobBase !== undefined ? { pathGlobBase } : {}),
     ...(gitSince !== undefined ? { gitSince } : {}),
     ...(sinceViaDeps ? { sinceViaDeps: true as const } : {}),
   }
@@ -221,13 +227,14 @@ function matchSelector(filter: ParsedFilter, projects: ProjectMeta[]): string[]
     if (filter.pathGlob !== undefined) {
       // The glob is matched against the project's own dir, as pnpm and
       // Turbo do: `./packages/*` is the packages directly under `packages`,
-      // `./packages/**` reaches the nested ones too.
+      // `./packages/**` reaches the nested ones too, and `./packages/kit/**`
+      // kit itself (kit's `check`: pnpm and Turbo read `**` as zero dirs too).
       for (const p of projects) {
         const rel = path
           .relative(filter.pathRoot ?? '', p.dir)
           .split(path.sep)
           .join('/')
-        if (filter.pathGlob.match(rel)) out.push(p.name)
+        if (filter.pathGlob.match(rel) || filter.pathGlobBase?.match(rel) === true) out.push(p.name)
       }
     }
     return out

package/src/workspace/migrate-scripts.ts

@@ -253,7 +253,7 @@ function upstreamBuildOnWorker(tasks: GeneratedTask[]): void {
  * task again beside the member's own (D-45).
  */
 const RUNS_MEMBERS =
-  /(^|[\s;&|(])(turbo|nx|lerna|ultra|wireit|nps|moon|rush|vx)(\s|$)|\bworkspaces?\s+(foreach|run)\b|\byarn\s+workspace\s|\bvp\s+run\s|\bcd\s/
+  /(^|[\s;&|(])(turbo|nx|lerna|ultra|wireit|nps|moon|rush|vx)(\s|$)|\bworkspaces?\s+(foreach|run)\b|\byarn\s+workspace\s|\bvp\s+run\s/
 
 /** A workspace flag, read only where a package manager takes it (`pmRunsMembers`). */
 const MEMBER_FLAG =
@@ -263,14 +263,15 @@ const MEMBER_FLAG =
  * The workspace flags are a package manager's: on the program it runs they
  * mean something else, and berry's `bench` (`yarn node -r ./setup.ts …`,
  * node's `--require`) was left out as running the members (D-81). With no
- * manager named, a `run` verb is one.
+ * manager named, `node <bin> run` is one (npm/cli's own npm), and not
+ * `docker run -w` (D-83).
  */
 function pmRunsMembers(script: string): boolean {
   for (const segment of script.split(/&&|\|\||[;|()]/)) {
     const words = segment.trim().split(/\s+/)
     let i = words.findIndex((w) => /^(pnpm|npm|yarn|bun)$/.test(w))
     // npm/cli runs itself: `node . run test --workspaces`.
-    if (i < 0) i = words.indexOf('run')
+    if (i < 0) i = words.findIndex((w, j) => w === 'run' && words[j - 2] === 'node')
     if (i < 0) continue
     // `exec`, `dlx` and `x` take the manager's flags up to the program name.
     let program = false
@@ -285,6 +286,25 @@ function pmRunsMembers(script: string): boolean {
   return false
 }
 
+const CD = /(?:^|[\s;&|(])cd\s+("[^"]*"|'[^']*'|[^\s;&|()]+)/g
+
+/**
+ * A `cd` into a member's directory, or one holding members, runs that
+ * member's work (kit's `cd packages/kit && vitest run`); bun's
+ * `typecheck` (`cd test && bun run typecheck`) enters no member and was
+ * left out (D-83). A target vx cannot read (`$DIR`, `~`) still counts.
+ */
+function cdsToMembers(script: string, rootDir: string, memberDirs: readonly string[]): boolean {
+  for (const m of script.matchAll(CD)) {
+    const target = m[1]!.replace(/^(["'])(.*)\1$/, '$2')
+    if (/[$`~*?]/.test(target) || target === '-') return true
+    const dir = path.resolve(rootDir, target)
+    const inside = (a: string, b: string): boolean => a === b || a.startsWith(b + path.sep)
+    if (memberDirs.some((d) => inside(d, dir) || inside(dir, d))) return true
+  }
+  return false
+}
+
 /** A package manager running a script by name: `pnpm build`, `npm run x`, `bun run x`. */
 const RUNS_SCRIPT =
   /(?:^|[\s;&|(])(?:pnpm|npm|yarn|bun)\s+(?:run(?:-script)?\s+)?([^\s;&|()'"-][^\s;&|()'"]*)/g
@@ -294,12 +314,21 @@ const RUNS_SCRIPT =
  * scripts: vite's `ci-docs` (`pnpm build && pnpm docs-build`) runs each
  * member's build through the root's own `build` (`pnpm -r … run build`).
  */
-function runningMembers(scripts: Readonly<Record<string, unknown>>): Set<string> {
+function runningMembers(
+  scripts: Readonly<Record<string, unknown>>,
+  rootDir: string,
+  memberDirs: readonly string[],
+): Set<string> {
   const text = Object.entries(scripts).filter(
     (e): e is [string, string] => typeof e[1] === 'string',
   )
   const out = new Set(
-    text.filter(([, v]) => RUNS_MEMBERS.test(` ${v}`) || pmRunsMembers(v)).map(([n]) => n),
+    text
+      .filter(
+        ([, v]) =>
+          RUNS_MEMBERS.test(` ${v}`) || pmRunsMembers(v) || cdsToMembers(v, rootDir, memberDirs),
+      )
+      .map(([n]) => n),
   )
   for (let grew = true; grew;) {
     grew = false
@@ -358,7 +387,11 @@ export function migrateScripts(
   )
   const rootScripts = (meta: ProjectMeta): Record<string, unknown> => {
     const scripts = scriptsOf(meta)
-    const runs = runningMembers(scripts)
+    const runs = runningMembers(
+      scripts,
+      meta.dir,
+      metas.filter((m) => m !== root).map((m) => m.dir),
+    )
     return Object.fromEntries(
       Object.entries(scripts).filter(
         ([n, v]) => typeof v === 'string' && !memberTasks.has(n) && !runs.has(n),