@vzn/vx 0.0.609 → 0.0.611

package/package.json

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

package/src/cache/inputs.ts

@@ -28,6 +28,7 @@ import {
   isLiteralPattern,
   normalizeGlob,
   outputMatcher,
+  realpathOf,
   relPosix,
   shellArgv,
   slashBraceExpansions,
@@ -1142,7 +1143,7 @@ export async function cleanWorkspaceOutputs(args: {
 
 function realOrNull(p: string): string | null {
   try {
-    return realpathSync(p)
+    return realpathOf(p)
   } catch {
     return null
   }

package/src/cli/lock.ts

@@ -8,7 +8,6 @@ import { relPosix, secretMask, xxh3hex } from '../util/index.js'
 import {
   findWorkspaceRoot,
   type LoadReads,
-  listProjects,
   loadProjectConfig,
   loadWorkspace,
   LOCKFILE_NAME,
@@ -19,6 +18,7 @@ import {
   type LockfileEntry,
   type ProjectMeta,
 } from '../workspace/index.js'
+import { discoverCliProjects } from './workspace-config.js'
 
 interface LockArgs {
   check: boolean
@@ -49,7 +49,13 @@ export async function lockCmd(args: readonly string[]): Promise<number> {
   const reads: LoadReads = new Map()
   const root = await findWorkspaceRoot(process.cwd(), reads)
   const workspace = await loadWorkspace(root, reads)
-  const all = await listProjects(workspace)
+  // As a run discovers them: a project a plugin's `discover` stage adds
+  // was left out of the lock, and every `--frozen` run then refused it
+  // with "run vx lock", which changed nothing (X-143).
+  // Sorted by name, as core's discovery is, for stable lockfile diffs.
+  const all = (await discoverCliProjects(workspace)).sort((a, b) =>
+    a.name < b.name ? -1 : a.name > b.name ? 1 : 0,
+  )
   const metas = all.filter((m): m is ConfiguredMeta => m.configPath !== null)
   // A project with no vx.config has nothing to freeze: its tasks (a plugin's,
   // or none) load live under --frozen too, so both verbs say how many the
@@ -83,7 +89,7 @@ function bareNote(bare: number): string {
 
 async function writeLock(root: string, metas: ConfiguredMeta[], bare: number): Promise<number> {
   const entries = await Promise.all(metas.map((m) => evaluateEntry(root, m)))
-  // `listProjects` sorts by name — stable lockfile diffs for free. Defined,
+  // Sorted by name above — stable lockfile diffs. Defined,
   // not assigned: a project named `__proto__` set the map's prototype (D-152).
   const projects: Record<string, LockfileEntry> = Object.fromEntries(
     metas.map((m, i) => [m.name, entries[i]!]),

package/src/cli/show.ts

@@ -154,13 +154,17 @@ export async function showCmd(args: readonly string[]): Promise<number> {
   }
 
   if (bareTask) {
-    const declaring = [...projects.values()].filter(
-      (p) => declaredTask(p.config, projectName!) !== undefined,
+    // As `vx run <task> --all` takes it: the default build is declared by no one (X-145).
+    const declares = (task: TaskConfig | undefined): boolean =>
+      task !== undefined && !isDefaultBuild(task)
+    const declaring = [...projects.values()].filter((p) =>
+      declares(declaredTask(p.config, projectName!)),
     )
     if (declaring.length === 0) {
       const names = new Set<string>()
       for (const p of projects.values())
-        for (const t of Object.keys(p.config.tasks ?? {})) names.add(t)
+        for (const [t, task] of Object.entries(p.config.tasks ?? {}))
+          if (declares(task)) names.add(t)
       // `nx show projects` lists them; here a bare `vx show` does.
       const nx = projectName === 'projects' ? ' (`nx show projects` is `vx show` here)' : ''
       throw new UserError(

package/src/cli/task-verb.ts

@@ -25,7 +25,10 @@ export async function taskVerbHint(
   const projects = await workspaceProjects(cwd)
   if (projects === null) return null
   const tasks = new Set<string>()
-  for (const p of projects.values()) for (const t of Object.keys(p.config.tasks ?? {})) tasks.add(t)
+  // The default build is no task `vx run` takes by name (X-145).
+  for (const p of projects.values())
+    for (const [t, task] of Object.entries(p.config.tasks ?? {}))
+      if (!isDefaultBuild(task)) tasks.add(t)
   const task = tasks.has(command) ? command : typo ? nearest(command, tasks) : undefined
   if (task === undefined) return null
   // Nx's `nx build app`: the word after the target is its project.

package/src/util/index.ts

@@ -74,7 +74,7 @@ export { isUnsupportedBun, MIN_BUN, unsupportedBunMessage } from './bun-version.
 export { executablePath, shellArgv, taskShell } from './which.js'
 export { procfsIsOwn } from './procfs.js'
 export { hangupIgnored } from './hangup.js'
-export { realPath } from './real-path.js'
+export { realPath, realpathOf } from './real-path.js'
 export {
   maskedCommand,
   maskedEmitter,

package/src/util/real-path.ts

@@ -1,4 +1,5 @@
-import { realpathSync } from 'node:fs'
+import { readlinkSync, realpathSync } from 'node:fs'
+import path from 'node:path'
 
 /**
  * A path's canonical spelling: the OS's own answer for the final path,
@@ -7,3 +8,50 @@ import { realpathSync } from 'node:fs'
 export function realPath(p: string): string {
   return realpathSync.native(p)
 }
+
+/**
+ * `realpathSync`, for a path holding a backslash too: Bun's answers ENOENT
+ * for any such path (1.4.2), so an output under `dist/a\b/` was dropped
+ * from its artifact. Such a path's links are read one by one. Throws as
+ * `realpathSync` does when the path is not there.
+ */
+export function realpathOf(p: string): string {
+  try {
+    return realpathSync(p)
+  } catch (err) {
+    if (!p.includes('\\')) throw err
+    return resolveLinks(p)
+  }
+}
+
+function resolveLinks(p: string): string {
+  // Not `path.resolve`: it folds `link/..` lexically, and the kernel
+  // takes `..` from where the link leads.
+  const abs = path.isAbsolute(p) ? p : `${process.cwd()}${path.sep}${p}`
+  let at = path.parse(abs).root
+  const pending = abs.slice(at.length).split(path.sep).filter(Boolean).reverse()
+  let hops = 0
+  while (pending.length > 0) {
+    const next = path.join(at, pending.pop()!)
+    let link: string
+    try {
+      link = readlinkSync(next)
+    } catch (err) {
+      if ((err as NodeJS.ErrnoException).code !== 'EINVAL') throw err
+      at = next
+      continue
+    }
+    // Linux's own bound on links followed in one lookup (MAXSYMLINKS).
+    if (++hops > 40) {
+      throw Object.assign(
+        new Error(`ELOOP: too many symbolic links encountered, realpath '${p}'`),
+        {
+          code: 'ELOOP',
+        },
+      )
+    }
+    if (path.isAbsolute(link)) at = path.parse(link).root
+    pending.push(...link.split('/').filter(Boolean).reverse())
+  }
+  return at
+}

package/src/workspace/workspace.ts

@@ -12,6 +12,7 @@ import {
   slashBraceExpansions,
   UserError,
   normalizeBunGlob,
+  realpathOf,
 } from '../util/index.js'
 import { type LoadReads, readOnce, unreadable } from './load-reads.js'
 import { repoIdOf } from './repo-id.js'
@@ -897,7 +898,7 @@ async function oneEntryPerPackage<T extends { dir: string }>(
 ): Promise<T[]> {
   const byReal = new Map<string, T[]>()
   for (const entry of group) {
-    const real = await realpath(entry.dir)
+    const real = realpathOf(entry.dir)
     const same = byReal.get(real)
     if (same === undefined) byReal.set(real, [entry])
     else same.push(entry)