@vzn/vx 0.0.646 → 0.0.649

package/src/workspace/bracket-literal.ts

@@ -0,0 +1,84 @@
+import { existsSync } from 'node:fs'
+import path from 'node:path'
+import { UserError } from '../util/index.js'
+import type { ProjectEntry } from './workspace.js'
+
+/**
+ * Each unescaped `[`…`]` class in a segment, or null when the segment holds
+ * none or another wildcard (`*`, `?`, `{`) a literal reading cannot settle.
+ */
+function classes(segment: string): [number, number][] | null {
+  const found: [number, number][] = []
+  for (let i = 0; i < segment.length; i++) {
+    const c = segment[i]!
+    if (c === '\\') i++
+    else if (c === '*' || c === '?' || c === '{') return null
+    else if (c === '[') {
+      const end = segment.indexOf(']', i + 2)
+      if (end === -1) return null
+      found.push([i, end])
+      i = end
+    }
+  }
+  return found.length > 0 ? found : null
+}
+
+const unescape = (s: string): string => s.replace(/\\(.)/g, '$1')
+const literalSegment = (s: string): boolean => !/(?<!\\)[*?{[]/.test(s)
+
+/**
+ * The glob with its first class segment escaped, when that segment taken
+ * literally names a path under `base`; else null. Only a literal prefix is
+ * followed: `**\/[id]` would need a walk, and this runs at `vx lock`.
+ */
+function literalBracketFix(glob: string, base: string): string | null {
+  const neg = glob.startsWith('!') ? '!' : ''
+  const segments = glob.slice(neg.length).split('/')
+  const prefix: string[] = []
+  for (const [i, s] of segments.entries()) {
+    if (literalSegment(s)) {
+      prefix.push(unescape(s))
+      continue
+    }
+    const spans = classes(s)
+    if (spans === null) return null
+    if (!existsSync(path.join(base, ...prefix, unescape(s)))) return null
+    let fixed = s
+    for (const [open, close] of spans.toReversed())
+      fixed = `${fixed.slice(0, open)}\\[${fixed.slice(open + 1, close)}\\]${fixed.slice(close + 1)}`
+    return neg + [...segments.slice(0, i), fixed, ...segments.slice(i + 1)].join('/')
+  }
+  return null
+}
+
+/**
+ * A bare `app/[id]/**` is the class matching `app/i` and `app/d`, never the
+ * route directory `app/[id]` (schema.md). Beside another glob it matched
+ * nothing with no warning, so an edit under the route replayed a stale hit
+ * (vercel/turborepo#14850 reads an existing bracketed path literally). vx
+ * keeps one reading and refuses the glob when that path exists. Checked by
+ * `vx lock` only: a run trusts the lock.
+ */
+export function checkBracketLiterals(root: string, projects: Iterable<ProjectEntry>): void {
+  for (const p of projects) {
+    for (const [task, t] of Object.entries(p.config.tasks ?? {})) {
+      const lists: [string, readonly string[] | undefined, string][] = [
+        ['inputs.files', t.inputs?.files, p.dir],
+        ['inputs.workspaceFiles', t.inputs?.workspaceFiles, root],
+        ['cache.outputs.files', t.cache?.outputs?.files, p.dir],
+        ['cache.outputs.workspaceFiles', t.cache?.outputs?.workspaceFiles, root],
+      ]
+      for (const [field, globs, base] of lists) {
+        for (const glob of globs ?? []) {
+          if (!glob.includes('[')) continue
+          const fixed = literalBracketFix(glob, base)
+          if (fixed === null) continue
+          throw new UserError(
+            `${p.name}#${task} ${field}: "${glob}" reads its brackets as a character class, ` +
+              `so it never matches the path of that name, which exists: write "${fixed}"`,
+          )
+        }
+      }
+    }
+  }
+}

package/src/workspace/canonical-dir.ts

@@ -0,0 +1,37 @@
+// A directory at where it leads, spelled under the workspace root: its own
+// module, as discovery and the filters both ask it and filter.ts is one
+// discovery imports.
+
+import path from 'node:path'
+import { isOutOfFds, realPath } from '../util/index.js'
+
+const realRoots = new Map<string, string>()
+
+/**
+ * `dir` at the directory it leads to, spelled under `root` as given (a
+ * root reached through a link, as macOS's temp dir is, keeps its
+ * spelling); `dir` itself when that directory lies outside the root; null
+ * when `dir` is not there. A workspace glob over linked packages (pnpm's
+ * `widgets/**`, `widgets/a -> ../submodules/a`) names the link, and git
+ * lists the config at the real directory: matched by spelling, one
+ * directory was two projects, the config-less twin at the link taking
+ * every edge.
+ */
+export function canonicalDir(root: string, dir: string): string | null {
+  const real = realOrNull(dir)
+  if (real === null) return null
+  let realRoot = realRoots.get(root)
+  if (realRoot === undefined) realRoots.set(root, (realRoot = realOrNull(root) ?? root))
+  const rel = path.relative(realRoot, real)
+  if (rel === '..' || rel.startsWith(`..${path.sep}`) || path.isAbsolute(rel)) return dir
+  return path.join(root, rel)
+}
+
+function realOrNull(p: string): string | null {
+  try {
+    return realPath(p)
+  } catch (err) {
+    if (isOutOfFds(err)) throw err
+    return null
+  }
+}

package/src/workspace/config-bytecode.ts

@@ -8,9 +8,10 @@
 // every input still has the bytes it was built from requires that instead.
 //
 // The bundle is built from the bytes it records, file by file, and is used
-// only while each recorded file still hashes the same and each bare import
-// still resolves to the file it did; anything else loads the source as
-// before and builds again. A graph the bundle could run differently is
+// only while each recorded file still hashes the same and each import still
+// resolves to the file it did (a relative one too: `./preset` finds a new
+// `preset.ts` before the bundled `preset.js`); anything else loads the
+// source as before and builds again. A graph the bundle could run differently is
 // never built: an `import.meta` field beyond its location, a `require` or
 // `import()` of a computed specifier (relative to the bundle, not the
 // file), top-level await, a CommonJS config, a file this process already
@@ -28,6 +29,7 @@ import {
   realpathSync,
   renameSync,
   rmSync,
+  writeFileSync,
 } from 'node:fs'
 import { writeFile } from 'node:fs/promises'
 import { createRequire } from 'node:module'
@@ -35,7 +37,7 @@ import path from 'node:path'
 import { xxh3hex } from '../util/index.js'
 
 /** Bumped when what a bundle holds, or how it is checked, changes. */
-const COMPILED_VERSION = 1
+const COMPILED_VERSION = 2
 
 /** What `import.meta` becomes in a bundled file: an identifier no source spells. */
 const META = '__vxImportMeta'
@@ -49,8 +51,8 @@ interface Manifest {
   entry: string
   /** Every file the bundle was built from, by real path, and its bytes' hash. */
   inputs: Record<string, string>
-  /** Each bare import: the importing file's directory, the specifier, the real path it resolved to. */
-  bare: [string, string, string][]
+  /** Each import: the importing file's directory, the specifier, the real path it resolved to. */
+  imports: [string, string, string][]
   /** The graph cannot be bundled faithfully: load the source while the inputs stay as they are. */
   skip?: true
 }
@@ -74,7 +76,7 @@ function fresh(manifest: Manifest): boolean {
     }
     if (xxh3hex(bytes) !== hash) return false
   }
-  for (const [from, spec, to] of manifest.bare) {
+  for (const [from, spec, to] of manifest.imports) {
     try {
       if (realpathSync(Bun.resolveSync(spec, from)) !== to) return false
     } catch {
@@ -127,7 +129,6 @@ const answered = new Map<string, { bytes: Uint8Array; ns: { default?: unknown }
  * process, and a bundle would run a second copy of its state.
  */
 export function loadedModules(root: string): Set<string> {
-  // Not `import.meta`: core's planner also runs as a browser script (the playground).
   return new Set(Object.keys(createRequire(path.join(root, 'index.js')).cache))
 }
 
@@ -165,6 +166,12 @@ export async function buildCompiled(
   const tmp = path.join(dir, `.tmp-${process.pid}-${Date.now()}`)
   try {
     mkdirSync(tmp, { recursive: true })
+    // Ignored by git under a cache dir elsewhere, where no `.vx/.gitignore` is written.
+    try {
+      writeFileSync(path.join(dir, '.gitignore'), '*\n', { flag: 'wx' })
+    } catch {
+      // there already: the user's or an earlier run's
+    }
     const built = await Bun.build({
       entrypoints: [configPath],
       target: 'bun',
@@ -232,7 +239,7 @@ export async function buildCompiled(
       version: COMPILED_VERSION,
       entry: entryFile,
       inputs,
-      bare: bareImports(built.metafile),
+      imports: importsOf(built.metafile),
       ...(faithful && bytecode ? {} : { skip: true as const }),
     }
     // The metafile names every input; one no onLoad saw (a JSON import) is
@@ -261,14 +268,13 @@ export async function buildCompiled(
   }
 }
 
-function bareImports(metafile: Bun.BuildMetafile | undefined): [string, string, string][] {
+function importsOf(metafile: Bun.BuildMetafile | undefined): [string, string, string][] {
   const out: [string, string, string][] = []
   for (const [input, entry] of Object.entries(metafile?.inputs ?? {})) {
     const from = path.dirname(realpathSync(path.resolve(input)))
     for (const imp of entry.imports) {
       const spec = imp.original
       if (imp.external === true || spec === undefined) continue
-      if (spec.startsWith('.') || path.isAbsolute(spec)) continue
       out.push([from, spec, realpathSync(path.resolve(imp.path))])
     }
   }

package/src/workspace/config-eval.ts

@@ -104,17 +104,19 @@ const nonJsonPaths = ${nonJsonPaths.toString()}
   }
 }
 // Bun's resolver reads \\ as a separator and ? as a query, so a config under a\\b or a?b is served
-// from the path as written (project-loader.ts's LITERAL_QUERY), read now.
+// from the path as written (project-loader.ts's LITERAL_QUERY), read now. By the request's id:
+// Bun 1.4.4 hands onLoad the path with \\ made /, and a\\b's config was read from a/b.
 let literal = false
+const literals = new Map()
 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)
+      build.onResolve({ filter: /\\?vx-literal=\\d+$/ }, (args) => ({ path: args.path, namespace: 'file' }))
+      build.onLoad({ filter: /\\?vx-literal=\\d+$/ }, async (args) => {
+        const file = literals.get(/=(\\d+)$/.exec(args.path)[1])
         return { contents: await globalThis.Bun.file(file).text(), loader: /\\.[cm]?ts$/.test(file) ? 'ts' : 'js' }
       })
     },
@@ -127,8 +129,6 @@ self.onmessage = async (e) => {
   // env var set in-process evaluated with it on the first load and without
   // it on every later one, and an embedder's second run() derived a
   // different key (D-61). Each request carries the parent's env now.
-  // Through globalThis: the playground bundles this source as a string, and
-  // its free-global scan reads a bare process after a paren as code.
   const live = globalThis.process.env
   for (const k of Object.keys(live)) if (!(k in env)) delete live[k]
   Object.assign(live, env)
@@ -173,8 +173,11 @@ self.onmessage = async (e) => {
   }
   try {
     const literalPath = /[\\\\?]/.test(path)
-    if (literalPath) serveLiteral()
-    const ns = await import(literalPath ? path + '?vx-literal' : path)
+    if (literalPath) {
+      serveLiteral()
+      literals.set(String(id), path)
+    }
+    const ns = await import(literalPath ? path + '?vx-literal=' + id : 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).
@@ -207,7 +210,16 @@ self.onmessage = async (e) => {
     // A thrown string or plain object has no message, and String() of a
     // null-prototype object throws here, inside the catch.
     const isError = err !== null && typeof err === 'object' && typeof err.message === 'string'
+    // A cause holds the reason a wrapper names only by its own words.
+    const causes = []
+    const seen = new Set([err])
+    for (let c = isError ? err.cause : undefined; c !== undefined && c !== null && !seen.has(c) && causes.length < 8; c = c.cause) {
+      seen.add(c)
+      const isE = typeof c === 'object' && typeof c.message === 'string'
+      causes.push(isE ? (c.stack ?? (c.name + ': ' + c.message)) : globalThis.Bun.inspect(c, { compact: true }))
+    }
     postMessage({
+      causes,
       id,
       ok: false,
       thrown: isError ? null : globalThis.Bun.inspect(err, { compact: true }),
@@ -240,6 +252,8 @@ interface WorkerReply {
   /** What a config threw that is not an Error, as `thrownValueMessage` shows it; null for an Error. */
   thrown?: string | null
   stack: string | null
+  /** Each `cause` under a thrown Error, outermost first, as its stack (or inspected value). */
+  causes?: string[]
   /** A transpile error's location — `BuildMessage.position`, trimmed to what the loader reads. */
   position: { file?: string; line?: number; column?: number } | null
 }
@@ -333,6 +347,13 @@ function acquireWorker(): Worker {
     if (msg.stack !== null) err.stack = msg.stack
     else delete err.stack
     if (msg.position !== null) err.position = msg.position
+    let cause: Error | undefined
+    for (const stack of (msg.causes ?? []).toReversed()) {
+      const c = new Error('', cause === undefined ? undefined : { cause })
+      c.stack = stack
+      cause = c
+    }
+    if (cause !== undefined) err.cause = cause
     p.reject(err)
   }
   w.onerror = (event: ErrorEvent): void => {