@vzn/vx 0.0.608 → 0.0.610

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vzn/vx",
-  "version": "0.0.608",
+  "version": "0.0.610",
   "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.608",
-    "@vzn/vx-linux-arm64": "0.0.608",
-    "@vzn/vx-darwin-x64": "0.0.608",
-    "@vzn/vx-darwin-arm64": "0.0.608"
+    "@vzn/vx-linux-x64": "0.0.610",
+    "@vzn/vx-linux-arm64": "0.0.610",
+    "@vzn/vx-darwin-x64": "0.0.610",
+    "@vzn/vx-darwin-arm64": "0.0.610"
   },
   "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/orchestrator/projects.ts

@@ -9,6 +9,7 @@ import type { ProjectConfig, TaskConfig } from '../config.js'
 import {
   frozenProjectConfigs,
   loadProjectConfigs,
+  LOCKFILE_NAME,
   validateProjectConfig,
   type LoadProjectConfigOptions,
   type LoadReads,
@@ -243,6 +244,21 @@ export async function loadProjects(args: LoadProjectsArgs): Promise<LoadedProjec
   // alike. With no root project it stays, and the graph's refusal says so.
   const root = path.resolve(workspaceRoot)
   const rootName = args.projectMetas.find((m) => path.resolve(m.dir) === root)?.name
+  // A project the lock holds whose config file is gone ran nothing under
+  // --frozen, green, though the lock promises what runs is what was
+  // locked (X-144); a run never even asks such a project for a task.
+  // Refused as a moved config is (D-88). With no lock at all, nothing was
+  // locked: a repo of config-less projects needs none.
+  if (lock) {
+    const bare = args.projectMetas.filter((m) => m.configPath === null)
+    const held = bare.length === 0 ? null : await lock().catch(() => null)
+    const gone = held === null ? undefined : bare.find((m) => Object.hasOwn(held.projects, m.name))
+    if (gone !== undefined && held !== null)
+      throw new UserError(
+        `${LOCKFILE_NAME} locks "${gone.name}" at ${held.projects[gone.name]!.configPath}, but it has no config now — ` +
+          `run \`vx lock\` to refresh, or delete ${LOCKFILE_NAME}`,
+      )
+  }
   const projects = new Map<string, ProjectEntry>()
   while (pending.length > 0) {
     const round = pending.splice(0, pending.length)

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)