@vzn/vx 0.0.366 → 0.0.368

package/package.json

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

package/src/orchestrator/execute-task.ts

@@ -399,6 +399,22 @@ async function executePersistentTask(args: ExecuteArgs): Promise<TaskOutcome> {
   try {
     await spawn.ready
   } catch (err) {
+    // A server the run's stop killed while it started is aborted, as any
+    // task the stop kills (item 962): it read `failed (never ready:
+    // exited, exit 130)` with a recap after every Ctrl-C (C-62). The stop
+    // aborts before it kills, so it is set by the time the child is gone.
+    // Read through a call: the early return above narrows `aborted` to
+    // false, but the stop can land during `spawn.ready`.
+    if (isAborted(args.stopSignal)) {
+      return {
+        node,
+        status: 'aborted',
+        exitCode: err instanceof PersistentReadyError ? (err.exitCode ?? 1) : 1,
+        durationMs: spawn.readyMs(),
+        wallclockStartNs,
+        wallclockEndNs: process.hrtime.bigint() - args.runStartHrTimeNs,
+      }
+    }
     const message = err instanceof Error ? err.message : String(err)
     // The task's OWN stream, not the process's: the frame is where a
     // reader looks for why a task failed, and a run with a custom logger
@@ -1300,3 +1316,7 @@ function taskEnv(node: TaskNode, step: ExecConfig, workspaceRoot: string): NodeJ
   env[VX_RUN_TASK_ENV] = node.id
   return env
 }
+
+function isAborted(signal: AbortSignal | undefined): boolean {
+  return signal?.aborted === true
+}

package/src/workspace/affected.ts

@@ -674,11 +674,27 @@ function revParse(workspaceRoot: string, ref: string): string | undefined {
     'ignore',
   )
   const sha = new TextDecoder().decode(proc.stdout).trim()
-  return proc.exitCode === 0 && sha.length > 0 ? sha : undefined
+  if (proc.exitCode !== 0 || sha.length === 0) return undefined
+  resolvedRefs.set(`${workspaceRoot}\0${ref}`, sha)
+  return sha
 }
 
+/**
+ * Refs `revParse` resolved to a commit, by workspace: the default base is
+ * found that way, and `verifyRef` asked git about it again, a synchronous
+ * spawn (~3.5 ms) of every bare `--affected`. A ref is fixed for a run.
+ */
+const resolvedRefs = new Map<string, string>()
+
+/** A ref that names an ancestor of HEAD by its own spelling (`HEAD~1`, `HEAD^`). */
+const HEAD_ANCESTOR = /^HEAD(?:~\d*|\^\d*)+$/
+
 /** `git merge-base <ref> HEAD`, or `ref` itself when the two share no ancestor. */
 async function mergeBase(workspaceRoot: string, ref: string): Promise<string> {
+  // HEAD's own ancestor is its merge base with HEAD: the commit it names,
+  // which the default base's search already resolved (`HEAD~1`).
+  const known = HEAD_ANCESTOR.test(ref) ? resolvedRefs.get(`${workspaceRoot}\0${ref}`) : undefined
+  if (known !== undefined) return known
   const proc = spawnGit(['merge-base', '--end-of-options', ref, 'HEAD'], workspaceRoot)
   const [out, exit] = await Promise.all([new Response(proc.stdout).text(), proc.exited])
   const sha = out.trim()
@@ -686,6 +702,7 @@ async function mergeBase(workspaceRoot: string, ref: string): Promise<string> {
 }
 
 async function verifyRef(workspaceRoot: string, ref: string): Promise<void> {
+  if (resolvedRefs.has(`${workspaceRoot}\0${ref}`)) return
   const proc = spawnGitSync(
     ['rev-parse', '--verify', '--quiet', '--end-of-options', ref],
     workspaceRoot,

package/src/workspace/migrate-scripts.ts

@@ -676,23 +676,49 @@ export function migrateScripts(
       .filter(([, v]) => typeof v === 'string' && v !== '')
       .map(([n]) => n),
   )
-  const rootScripts = (meta: ProjectMeta): Record<string, unknown> => {
+  // The root scripts left out, by why: jest's root `build` (every package's)
+  // went unnamed beside the website's, and `vx run build --all` built the
+  // website alone (D-85). A left-out script's `pre` / `post` hook goes with
+  // it where the manager runs hooks: kept, it became a task of its own.
+  const leftOut = (meta: ProjectMeta): { runs: string[]; shared: string[]; out: Set<string> } => {
     const scripts = scriptsOf(meta)
     const runs = runningMembers(
       scripts,
       meta.dir,
       metas.filter((m) => m !== root).map((m) => m.dir),
     )
+    const hooks = runsScriptHooks(meta.dir, hookMemo) !== null
+    const hookOf = (n: string): string | undefined => {
+      const base = hooks ? /^(?:pre|post)(.+)$/.exec(n)?.[1] : undefined
+      return base !== undefined && typeof scripts[base] === 'string' ? base : undefined
+    }
+    // A hook rides in its script's command, so it is judged with it.
+    const named = Object.keys(scripts).filter(
+      (n) => typeof scripts[n] === 'string' && !LIFECYCLE.test(n) && hookOf(n) === undefined,
+    )
+    const left = {
+      runs: named.filter((n) => runs.has(n)),
+      shared: named.filter((n) => memberTasks.has(n) && !runs.has(n)),
+    }
+    const outNames = new Set([...left.runs, ...left.shared])
+    const out = new Set(
+      Object.keys(scripts).filter((n) => outNames.has(n) || outNames.has(hookOf(n) ?? '')),
+    )
+    return { ...left, out }
+  }
+  const rootScripts = (meta: ProjectMeta): Record<string, unknown> => {
+    const scripts = scriptsOf(meta)
+    const { out } = leftOut(meta)
     return Object.fromEntries(
-      Object.entries(scripts).filter(
-        ([n, v]) => typeof v === 'string' && !memberTasks.has(n) && !runs.has(n),
-      ),
+      Object.entries(scripts).filter(([n, v]) => typeof v === 'string' && !out.has(n)),
     )
   }
   const rootMapped =
     rootMeta === undefined
       ? 0
       : Object.keys(rootScripts(rootMeta)).filter((n) => !LIFECYCLE.test(n)).length
+  const listed = (names: readonly string[]): string =>
+    names.slice(0, 8).join(', ') + (names.length > 8 ? ` and ${names.length - 8} more` : '')
   const outsideScripts = outside?.['scripts']
   const outsideRuns =
     typeof outsideScripts === 'object' &&
@@ -720,8 +746,15 @@ export function migrateScripts(
         : 'package.json'
       : undefined)
   if (rootName !== undefined && rootMapped > 0) {
+    const { runs, shared } = leftOut(rootMeta!)
     notes.push(
-      `${rootName} (the workspace root): its scripts that check the whole repo are its tasks; those that run the members (${membersExample(rootMeta && rootManager(rootMeta.dir, hookMemo))}, a runner) or share a member's task name are left out`,
+      `${rootName} (the workspace root): its scripts that check the whole repo are its tasks` +
+        (runs.length > 0
+          ? `; left out as running the members (${membersExample(rootMeta && rootManager(rootMeta.dir, hookMemo))}, a runner): ${listed(runs)}`
+          : '') +
+        (shared.length > 0
+          ? `; left out as a member's task name, so \`--all\` never runs one twice: ${listed(shared)} — one that does other work maps by hand under a name of its own`
+          : ''),
     )
   } else if (rootName === 'package.json' && outsideDir !== undefined && unnamedMaps().length > 0) {
     // react's nameless root: "its scripts run the workspace" was not why,