@vzn/vx 0.0.597 → 0.0.599

package/src/orchestrator/plugin.ts

@@ -15,7 +15,7 @@ import type { Cache, CacheLayer, CachePolicy } from '../cache/index.js'
 import { PLUGIN_PACKAGE, type ProjectConfig, type WorkspaceConfig } from '../config.js'
 import type { TaskExecutor } from '../exec/index.js'
 import type { TaskNode, TaskOutcome } from '../graph/index.js'
-import { nearest, UserError } from '../util/index.js'
+import { maskedLine, nearest, UserError } from '../util/index.js'
 import type { ProjectMeta } from '../workspace/index.js'
 import type { EventBus, RunStartInfo } from './events.js'
 import type { TelemetryContext, TelemetrySink } from './telemetry.js'
@@ -716,7 +716,10 @@ export async function installPlugins(args: InstallPluginsArgs): Promise<() => vo
       for (const d of disposers) d()
       throw new PluginSetupError(
         plugin,
-        `plugin '${plugin.name}' failed in setup: ${err instanceof Error ? err.message : String(err)}`,
+        // Masked at the source, as plugin-host.ts's `safe()` does (L-11).
+        maskedLine(
+          `plugin '${plugin.name}' failed in setup: ${err instanceof Error ? err.message : String(err)}`,
+        ),
       )
     }
   }

package/src/orchestrator/prepare.ts

@@ -379,9 +379,11 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
     // it, and the run said no project did (C-3). Only what is still
     // unjudged pays for the rest of the workspace.
     unresolvedTasks = undeclaredIn(unresolvedTasks, projects)
+    // By name, not by count: a config-less project in the scope counts as
+    // loaded, and a changed one hid an unloaded `test` declarer (X-129).
     if (
-      projects.size < projectsWithConfigs.length &&
-      unresolvedTasks.some((t) => !t.includes('#'))
+      unresolvedTasks.some((t) => !t.includes('#')) &&
+      projectsWithConfigs.some((m) => !projects.has(m.name))
     ) {
       unresolvedTasks = await declaredNowhere(unresolvedTasks, () =>
         loadProjects({ ...loadArgs, seeds: 'all', closure: false, staged: projects }),

package/src/orchestrator/projects.ts

@@ -321,7 +321,7 @@ const DEFAULT_BUILD: TaskConfig = Object.freeze({
     inputs: Object.freeze({ files: Object.freeze(['**']) }),
     outputs: Object.freeze({ files: Object.freeze([]) }),
   }),
-}) as unknown as TaskConfig
+})
 
 /** The default `build`, which a menu of the tasks a user declared leaves out. */
 export function isDefaultBuild(task: TaskConfig | undefined): boolean {

package/src/orchestrator/run-context.ts

@@ -379,7 +379,7 @@ function ciLinks(provider: string, env: Record<string, string | undefined>): CiL
     default:
       return {}
   }
-  return Object.fromEntries(Object.entries(links).filter(([, x]) => x !== undefined)) as CiLinks
+  return Object.fromEntries(Object.entries(links).filter(([, x]) => x !== undefined))
 }
 
 /** Host name (null on failure) + platform + arch. */

package/src/orchestrator/run-lock.ts

@@ -66,7 +66,8 @@ import { rmdirSync, unlinkSync } from 'node:fs'
 import { mkdir, readdir, readFile, rename, rm, rmdir, unlink, writeFile } from 'node:fs/promises'
 import os from 'node:os'
 import path from 'node:path'
-import { isTmpdirRefusal, procfsIsOwn, TMPDIR_HINT, xxh3hex } from '../util/index.js'
+import { VX_RUN_TASK_ENV, VX_RUN_WORKSPACE_ENV } from '../exec/index.js'
+import { isTmpdirRefusal, procfsIsOwn, TMPDIR_HINT, UserError, xxh3hex } from '../util/index.js'
 
 /** Runs in this process currently holding the lock, per lock directory. */
 const heldHere = new Map<string, number>()
@@ -329,6 +330,14 @@ export async function acquireRunLock(
   opts: RunLockOptions,
 ): Promise<() => Promise<void>> {
   const lockDir = runLockPath(workspaceRoot, opts.dir)
+  // A task's own process (`vx cache prune` in a task) would wait for the
+  // run that started it, which holds the lock until that task ends.
+  const outer = process.env[VX_RUN_WORKSPACE_ENV]
+  if (outer !== undefined && runLockPath(outer, opts.dir) === lockDir) {
+    throw new UserError(
+      `this vx runs inside task ${process.env[VX_RUN_TASK_ENV] ?? '<unknown>'} of a vx run on this workspace, which holds its run lock until it ends — run it before or after that run, not from one of its tasks`,
+    )
+  }
   const started = Date.now()
   let said = false
   const release = async (): Promise<void> => {

package/src/workspace/config-cache.ts

@@ -606,8 +606,12 @@ export function configEvalKeyFromIdentities(a: {
  * `node_modules`, the config itself excluded. `vx watch` watches these: a
  * shared preset outside the project (`../../shared/preset.mjs`, the way
  * configs compose) changed what a run evaluates and no watcher saw it
- * (item 949). A file that cannot be read or resolved ends its branch.
+ * (item 949). A file that cannot be read or resolved ends its branch; one
+ * that cannot be resolved is still listed, by the name it would have.
  */
+// The names an extensionless relative import may resolve to, as Bun tries them.
+const IMPORT_EXTENSIONS = ['.ts', '.tsx', '.mts', '.cts', '.js', '.jsx', '.mjs', '.cjs', '.json']
+
 export async function configImports(configPath: string): Promise<string[]> {
   const seen = new Set<string>([configPath])
   const out: string[] = []
@@ -635,6 +639,16 @@ export async function configImports(configPath: string): Promise<string[]> {
         dir ??= realDirOf(file)
         resolved = realPath(Bun.resolveSync(spec, dir))
       } catch {
+        // Missing for now, still imported: the config that names it fails
+        // to load until it is back, and a list without it left `vx watch`
+        // deaf to its return. Named as written, and not walked.
+        if (dir === undefined) continue
+        for (const ext of path.extname(spec) === '' ? IMPORT_EXTENSIONS : ['']) {
+          const missing = path.resolve(dir, spec + ext)
+          if (seen.has(missing)) continue
+          seen.add(missing)
+          out.push(missing)
+        }
         continue
       }
       if (seen.has(resolved) || resolved.split(path.sep).includes('node_modules')) continue

package/src/workspace/config-eval.ts

@@ -103,6 +103,23 @@ const nonJsonPaths = ${nonJsonPaths.toString()}
     throw new Error('process.exit(' + (code ?? '') + ') in a config: ' + ${JSON.stringify(CONFIG_EXIT)})
   }
 }
+// Bun's resolver reads \\ as a separator, so a config under a\\b is served
+// from the path as written (project-loader.ts's LITERAL_QUERY), read now.
+let literal = false
+const serveLiteral = () => {
+  if (literal) return
+  literal = true
+  globalThis.Bun.plugin({
+    name: 'vx-config-literal',
+    setup(build) {
+      build.onResolve({ filter: /\\?vx-literal$/ }, (args) => ({ path: args.path, namespace: 'file' }))
+      build.onLoad({ filter: /\\?vx-literal$/ }, async (args) => {
+        const file = args.path.slice(0, -'?vx-literal'.length)
+        return { contents: await globalThis.Bun.file(file).text(), loader: /\\.[cm]?ts$/.test(file) ? 'ts' : 'js' }
+      })
+    },
+  })
+}
 self.onmessage = async (e) => {
   const { id, path, env } = e.data
   // A Worker starts with the process's STARTUP environment, not the
@@ -155,7 +172,9 @@ self.onmessage = async (e) => {
     if (umaskIn !== null && globalThis.process.umask() !== umaskIn) globalThis.process.umask(umaskIn)
   }
   try {
-    const ns = await import(path)
+    const literalPath = path.includes('\\\\')
+    if (literalPath) serveLiteral()
+    const ns = await import(literalPath ? path + '?vx-literal' : path)
     // Awaited as the in-process load's async return flattens it: a Promise
     // default loaded on a run and was refused as "an instance of Promise"
     // on every later evaluation in the process (D-5).

package/src/workspace/project-loader.ts

@@ -87,7 +87,12 @@ function assertDefaultObject(mod: unknown, kind: string, configPath: string): vo
 const heldSources = new Map<string, { source: string; uses: number }>()
 let serving = false
 
-const HELD_QUERY = /\?vx-held=([0-9a-f]+)$/
+const HELD_QUERY = /\?vx-(?:held|literal)=([0-9a-f]+)$/
+
+// Bun's resolver reads `\` as a separator, even in a file: URL, so a
+// config under `a\b` was looked for under `a/b`. Resolving it here keeps
+// the path as written; only the served load can take it.
+const LITERAL_QUERY = /\?vx-literal=[0-9a-f]+$/
 
 function serveHeldSources(): void {
   if (serving) return
@@ -95,6 +100,7 @@ function serveHeldSources(): void {
   Bun.plugin({
     name: 'vx-config-bytes',
     setup(build) {
+      build.onResolve({ filter: LITERAL_QUERY }, (args) => ({ path: args.path, namespace: 'file' }))
       build.onLoad({ filter: HELD_QUERY }, (args) => ({
         contents: heldSources.get(HELD_QUERY.exec(args.path)![1]!)!.source,
         loader: /\.[cm]?ts\?/.test(args.path) ? 'ts' : 'js',
@@ -136,7 +142,7 @@ const COMMONJS_HINT =
   /\b(?:module|exports|require|this|__dirname|__filename)\b|\\|\bexport\s*=(?!=)/
 
 /** vx's module-cache query, which no user wrote: stripped from anything shown to them. */
-const BUST_QUERY = /\?vx-(?:bust|held)=[^'"\s]*/g
+const BUST_QUERY = /\?vx-(?:bust|held|literal)=[^'"\s]*/g
 
 // Bun has native TS / ESM execution — no transpiler dep needed. We fold
 // a short content hash into the import URL as a cache-bust key so that:
@@ -157,10 +163,18 @@ async function loadDefaultExport(
   // URL yet, and a repeat load (the one that could replay an evaluation
   // made under earlier env values) re-evaluates in a worker instead
   // (`loadedConfigs`, item 678).
+  const literal = configPath.includes('\\')
   const source =
-    kind === 'Project' ? servableSource(bytes, /\.[cm]?ts$/.test(configPath) ? 'ts' : 'js') : null
+    kind === 'Project' || literal
+      ? servableSource(bytes, /\.[cm]?ts$/.test(configPath) ? 'ts' : 'js')
+      : null
+  if (literal && source === null) {
+    throw new UserError(
+      `${kind} config ${configPath} sits under a path that holds a backslash, which Bun loads only as an ES module in UTF-8`,
+    )
+  }
   const hash = xxh3hex(bytes)
-  const specifier = `${configPath}?vx-${source !== null ? 'held' : 'bust'}=${hash}`
+  const specifier = `${configPath}?vx-${literal ? 'literal' : source !== null ? 'held' : 'bust'}=${hash}`
   if (source !== null) {
     serveHeldSources()
     holdSource(hash, source)