@vzn/vx 0.0.597 → 0.0.598

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)