@vzn/vx 0.0.651 → 0.0.653

package/src/workspace/config-eval.ts

@@ -36,8 +36,10 @@
 // with the message the first load gives (item 701).
 
 import path from 'node:path'
-import { MAX_TIMEOUT_MS, parseDuration, UserError } from '../util/index.js'
+import * as ui from '../ui/index.js'
+import { MAX_TIMEOUT_MS, parseDuration, testTimerMs, UserError } from '../util/index.js'
 import { nonJsonMessage, nonJsonPaths, type NonJsonValue } from './json-data.js'
+import { changedExports, exportState } from './module-state.js'
 
 /** Why a config's `process.exit` throws, on both load paths (D-65). */
 export const CONFIG_EXIT = 'a config exports its object; it cannot end the run'
@@ -76,6 +78,8 @@ export const WATCHED_BUILTIN_NAMES = [
 
 const WORKER_SRC = `
 const nonJsonPaths = ${nonJsonPaths.toString()}
+const exportState = ${exportState.toString()}
+const changedExports = ${changedExports.toString()}
 // The parent's stdout is a verb's JSON, and a config printing on a repeat
 // load wrote into it: the parent's own redirect covers the parent thread
 // only (D-64). This worker only evaluates configs, so every route to fd 1
@@ -171,6 +175,15 @@ self.onmessage = async (e) => {
   const umaskBack = () => {
     if (umaskIn !== null && globalThis.process.umask() !== umaskIn) globalThis.process.umask(umaskIn)
   }
+  // Asked which shared modules this config changes: each is imported
+  // first, so its state before the config's own code runs is known.
+  const modules = []
+  for (const m of e.data.modules ?? []) {
+    try {
+      const ns = await import(m)
+      modules.push([m, ns, exportState(ns)])
+    } catch {}
+  }
   try {
     const literalPath = /[\\\\?]/.test(path)
     if (literalPath) {
@@ -196,6 +209,7 @@ self.onmessage = async (e) => {
       json: isObject && nonJson.length === 0 ? JSON.stringify(mod) : null,
       fn: typeof mod === 'function',
       changed: report,
+      modules: modules.filter(([, ns, before]) => changedExports(before, exportState(ns)).length > 0).map(([m]) => m),
     })
   } catch (thrown) {
     // Two syntax errors arrive as one AggregateError, whose own message
@@ -289,6 +303,41 @@ export function evalBudgetMs(): number {
   return n !== null && n > 0 && n <= MAX_TIMEOUT_MS ? n : 30_000
 }
 
+/** How long a config evaluates before vx says it is still waiting on it. */
+const EVAL_NOTICE_MS = 5_000
+
+/**
+ * Calls `expire` once `budget` ms pass, and says once, at the notice mark,
+ * which config is still evaluating: a top-level await that never settles
+ * was otherwise `budget` ms of silence. One timer at a time, re-armed at the
+ * notice, so a load costs the one timer it always had. Returns the clear.
+ * `hold` keeps the process alive for it: in process, nothing else holds
+ * it under a never-settled top-level await, and the run exited silently.
+ */
+export function evalDeadline(
+  kind: string,
+  configPath: string,
+  budget: number,
+  expire: () => void,
+  hold: boolean,
+): () => void {
+  const noticeMs = testTimerMs('CONFIG_EVAL_NOTICE', EVAL_NOTICE_MS)
+  let timer: ReturnType<typeof setTimeout>
+  if (noticeMs < budget) {
+    timer = setTimeout(() => {
+      const time = (ms: number): string => (ms < 1000 ? `${ms} ms` : `${ms / 1000} s`)
+      ui.sayLine(
+        'warn',
+        `${kind} config ${configPath} still evaluating after ${time(noticeMs)}; vx gives up at ${time(budget)} (VX_CONFIG_WORKER_TIMEOUT)`,
+      )
+      timer = setTimeout(expire, budget - noticeMs)
+      if (!hold) timer.unref()
+    }, noticeMs)
+  } else timer = setTimeout(expire, budget)
+  if (!hold) timer.unref()
+  return () => clearTimeout(timer)
+}
+
 const pending = new Map<number, Pending>()
 let worker: Worker | null = null
 let inFlight = 0
@@ -410,7 +459,7 @@ export async function evaluateConfigFresh(configPath: string): Promise<unknown>
   inFlight++
   // Declared out here so the `finally` can clear it on EVERY exit, including a
   // rejection. See the note at the clear itself.
-  let timer: ReturnType<typeof setTimeout> | undefined
+  let clear: (() => void) | undefined
   try {
     const w = acquireWorker()
     // A worker thread the OS kills — memory pressure on a loaded CI box, a
@@ -422,14 +471,19 @@ export async function evaluateConfigFresh(configPath: string): Promise<unknown>
     const budget = evalBudgetMs()
     const reply = await new Promise<WorkerReply>((resolve, reject) => {
       pending.set(id, { resolve, reject, configPath })
-      timer = setTimeout(() => {
-        rejectAll(new Error(`config worker did not answer within ${budget}ms`))
-        if (worker !== null) {
-          worker.terminate()
-          worker = null
-        }
-      }, budget)
-      timer.unref?.()
+      clear = evalDeadline(
+        'Project',
+        configPath,
+        budget,
+        () => {
+          rejectAll(new Error(`config worker did not answer within ${budget}ms`))
+          if (worker !== null) {
+            worker.terminate()
+            worker = null
+          }
+        },
+        false,
+      )
       w.postMessage({ id, path: abs, env: { ...process.env } })
     })
     const [nonJson] = reply.nonJson
@@ -445,7 +499,7 @@ export async function evaluateConfigFresh(configPath: string): Promise<unknown>
     // later fired it ran `rejectAll()` and terminated whatever worker was
     // current by then, killing an unrelated healthy round with a timeout
     // message naming a budget nobody set for it.
-    clearTimeout(timer)
+    clear?.()
     pending.delete(id)
     retireIfIdle()
   }
@@ -459,20 +513,40 @@ export async function evaluateConfigFresh(configPath: string): Promise<unknown>
  * changes nothing, fails before reporting, or outlives the budget.
  */
 export async function builtinsChangedBy(configPath: string): Promise<string[]> {
+  return (await blame(configPath, { blame: true })).changed ?? []
+}
+
+/**
+ * Which of `modules` evaluating `configPath` alone changes the exported
+ * values of, in a worker of its own: a round that found a module several
+ * configs import changed asks each of them in turn, to name the one that
+ * changed it. Empty as `builtinsChangedBy` is.
+ */
+export async function modulesChangedBy(
+  configPath: string,
+  modules: readonly string[],
+): Promise<string[]> {
+  return (await blame(configPath, { modules })).modules ?? []
+}
+
+async function blame(
+  configPath: string,
+  ask: { blame?: true; modules?: readonly string[] },
+): Promise<{ changed?: string[]; modules?: string[] }> {
   const w = new Worker(WORKER_URL)
   try {
-    return await new Promise<string[]>((resolve) => {
-      const timer = setTimeout(() => resolve([]), evalBudgetMs())
+    return await new Promise((resolve) => {
+      const timer = setTimeout(() => resolve({}), evalBudgetMs())
       timer.unref?.()
       w.onmessage = (event: MessageEvent): void => {
         clearTimeout(timer)
-        resolve((event.data as { changed?: string[] }).changed ?? [])
+        resolve(event.data as { changed?: string[]; modules?: string[] })
       }
       w.onerror = (): void => {
         clearTimeout(timer)
-        resolve([])
+        resolve({})
       }
-      w.postMessage({ id: 0, path: path.resolve(configPath), env: { ...process.env }, blame: true })
+      w.postMessage({ id: 0, path: path.resolve(configPath), env: { ...process.env }, ...ask })
     })
   } finally {
     w.terminate()

package/src/workspace/config-imports.ts

@@ -474,8 +474,15 @@ function scanLocalImports(
   fromDir: string,
   loader: 'ts' | 'js',
   memo: LookupMemo,
+  /** Also follow a bare specifier into a package linked from outside `node_modules` ({@link linkedPackageFile}). */
+  linked = false,
 ): string[] {
-  if (!LOCAL_CANDIDATE.test(source) && !hasAliasCandidate(source, fromDir, memo.tsconfig)) return []
+  if (
+    !LOCAL_CANDIDATE.test(source) &&
+    !hasAliasCandidate(source, fromDir, memo.tsconfig) &&
+    !(linked && hasBareCandidate(source))
+  )
+    return []
   let specifiers: string[]
   try {
     specifiers = scanner(loader)
@@ -488,13 +495,41 @@ function scanLocalImports(
   for (const spec of specifiers) {
     // Selection may widen on a named path; it is never hashed.
     const t = localTarget(spec, fromDir, memo)
-    if (t === undefined) continue
-    if ('file' in t) out.push(t.file)
+    if (t === undefined) {
+      const file = linked ? linkedPackageFile(spec, fromDir) : undefined
+      if (file !== undefined) out.push(file)
+    } else if ('file' in t) out.push(t.file)
     else out.push(...t.named)
   }
   return out
 }
 
+/**
+ * The file a bare `spec` loads when the nearest `node_modules/<package>`
+ * above `fromDir` links to a directory outside any `node_modules`: a
+ * workspace package (`workspace:*`), whose source the lockfile does not
+ * pin. Realpath'd. Undefined for an installed package, or none installed:
+ * resolving then could ask the registry.
+ */
+function linkedPackageFile(spec: string, fromDir: string): string | undefined {
+  if (spec.startsWith('.') || spec.startsWith('/') || !needsLookup(spec)) return undefined
+  const pkg = packageOf(spec)
+  for (let dir = fromDir; ;) {
+    const installed = path.join(dir, 'node_modules', pkg)
+    if (existsSync(installed)) {
+      if (realpathOr(installed).split(path.sep).includes('node_modules')) return undefined
+      try {
+        return realpathOr(Bun.resolveSync(spec, fromDir))
+      } catch {
+        return undefined
+      }
+    }
+    const up = path.dirname(dir)
+    if (up === dir) return undefined
+    dir = up
+  }
+}
+
 export interface ConfigImportOwnersArgs {
   /**
    * Realpath'd HERE, not by the caller. `Bun.resolveSync` returns realpath'd
@@ -516,6 +551,11 @@ export interface ConfigImportOwners {
   owners: Set<string>
   /** A changed file a workspace config imports, which can re-key any task. */
   workspace?: string
+  /**
+   * The files a workspace config imports above the workspace root,
+   * realpath'd: `changed` cannot name them, so the caller asks git.
+   */
+  outside?: string[]
 }
 
 const TS_EXT = new Set(['.ts', '.mts', '.cts'])
@@ -527,7 +567,7 @@ const RESOLVED_EXTENSIONS = ['.ts', '.tsx', '.mts', '.cts', '.js', '.jsx', '.mjs
 export async function configImportOwners(a: ConfigImportOwnersArgs): Promise<ConfigImportOwners> {
   const selected = new Set<string>()
   const wsConfigs = a.workspaceConfigs ?? []
-  if (a.changed.length === 0) return { owners: selected }
+  if (a.changed.length === 0 && wsConfigs.length === 0) return { owners: selected }
   if (a.skip.size === a.projects.length && wsConfigs.length === 0) return { owners: selected }
   const workspaceRoot = await realpath(a.workspaceRoot).catch(() => a.workspaceRoot)
 
@@ -549,39 +589,50 @@ export async function configImportOwners(a: ConfigImportOwnersArgs): Promise<Con
   const memo = lookupMemo()
   const importedBy = new Map<string, string[]>()
   const visited = new Set<string>()
-  // A level at a time, its files read together: one awaited read per
-  // config put 5,000 of them 200 ms behind (D-23).
-  let frontier = [...roots.keys(), ...wsRoots]
-  while (frontier.length > 0) {
-    const read = await Promise.all(
-      frontier.map(async (file) => {
-        if (visited.has(file)) return null
-        visited.add(file)
-        try {
-          return { file, source: await Bun.file(file).text() }
-        } catch (err) {
-          // Out of descriptors is this level's width, not the file: read as
-          // no edges, it dropped every project the import selects (D-63).
-          if (isOutOfFds(err)) throw err
-          return null // unreadable: no edges, and not this pass's problem to report
+  // The workspace config is loaded live, not from the lock, so its walk
+  // goes further: into a workspace package it names (linked into
+  // node_modules), and above the root, which `changed` cannot name.
+  const outside = new Set<string>()
+  const walkImports = async (start: string[], ws: boolean): Promise<void> => {
+    // A level at a time, its files read together: one awaited read per
+    // config put 5,000 of them 200 ms behind (D-23).
+    let frontier = start
+    while (frontier.length > 0) {
+      const read = await Promise.all(
+        frontier.map(async (file) => {
+          if (visited.has(file)) return null
+          visited.add(file)
+          try {
+            return { file, source: await Bun.file(file).text() }
+          } catch (err) {
+            // Out of descriptors is this level's width, not the file: read as
+            // no edges, it dropped every project the import selects (D-63).
+            if (isOutOfFds(err)) throw err
+            return null // unreadable: no edges, and not this pass's problem to report
+          }
+        }),
+      )
+      frontier = []
+      for (const entry of read) {
+        if (entry === null) continue
+        const { file, source } = entry
+        const loader = TS_EXT.has(path.extname(file)) ? 'ts' : 'js'
+        for (const target of scanLocalImports(source, path.dirname(file), loader, memo, ws)) {
+          if (target.split(path.sep).includes('node_modules')) continue
+          if (!target.startsWith(workspaceRoot + path.sep)) {
+            if (!ws) continue
+            outside.add(target)
+          }
+          const list = importedBy.get(target)
+          if (list) list.push(file)
+          else importedBy.set(target, [file])
+          frontier.push(target)
         }
-      }),
-    )
-    frontier = []
-    for (const entry of read) {
-      if (entry === null) continue
-      const { file, source } = entry
-      const loader = TS_EXT.has(path.extname(file)) ? 'ts' : 'js'
-      for (const target of scanLocalImports(source, path.dirname(file), loader, memo)) {
-        if (!target.startsWith(workspaceRoot + path.sep)) continue
-        if (target.split(path.sep).includes('node_modules')) continue
-        const list = importedBy.get(target)
-        if (list) list.push(file)
-        else importedBy.set(target, [file])
-        frontier.push(target)
       }
     }
   }
+  await walkImports([...wsRoots], true)
+  await walkImports([...roots.keys()], false)
 
   let workspace: string | undefined
   const seen = new Set<string>()
@@ -597,7 +648,8 @@ export async function configImportOwners(a: ConfigImportOwnersArgs): Promise<Con
     if (wsRoots.has(file)) workspace ??= from
     for (const importer of importedBy.get(file) ?? []) walk.push([importer, from])
   }
-  return workspace === undefined ? { owners: selected } : { owners: selected, workspace }
+  if (workspace !== undefined) return { owners: selected, workspace }
+  return outside.size === 0 ? { owners: selected } : { owners: selected, outside: [...outside] }
 }
 
 /**
@@ -618,12 +670,15 @@ function realDirOf(file: string): string {
  * (item 949). A file that cannot be read ends its branch; an import that
  * cannot be resolved is still listed, by the names it would have.
  * `configSource` is the config's, when the caller has read it; `read` reads the
- * rest, for a caller that keeps what was read.
+ * rest, for a caller that keeps what was read. `statics`, when given,
+ * gets each file the config reaches through static imports alone: the ones
+ * its evaluation always evaluates, a dynamic `import()` aside.
  */
 export async function configImports(
   configPath: string,
   configSource?: string,
   read: (file: string) => Promise<string> = (file) => Bun.file(file).text(),
+  statics?: Set<string>,
 ): Promise<string[]> {
   const seen = new Set<string>([configPath])
   const memo = lookupMemo()
@@ -640,21 +695,20 @@ export async function configImports(
     } finally {
       given = undefined
     }
-    let specs: string[]
+    let specs: Array<{ path: string; kind: string }>
     try {
-      specs = scanner(TS_EXT.has(path.extname(file)) ? 'ts' : 'js')
-        .scanImports(source)
-        .map((i) => i.path)
+      specs = scanner(TS_EXT.has(path.extname(file)) ? 'ts' : 'js').scanImports(source)
     } catch {
       // A source the parser refuses (mid-edit) keeps the imports a plain
       // match sees: watching too few files is what this list exists to
       // prevent.
       specs = [...source.matchAll(/\bfrom\s*['"]([^'"]+)['"]|\bimport\s*['"]([^'"]+)['"]/g)].map(
-        (m) => (m[1] ?? m[2])!,
+        (m) => ({ path: (m[1] ?? m[2])!, kind: 'import-statement' }),
       )
     }
+    const fromStatic = statics !== undefined && (file === configPath || statics.has(file))
     let dir: string | undefined
-    for (const spec of specs) {
+    for (const { path: spec, kind } of specs) {
       let t: ReturnType<typeof localTarget>
       try {
         dir ??= realDirOf(file)
@@ -679,6 +733,7 @@ export async function configImports(
       seen.add(resolved)
       out.push(resolved)
       queue.push(resolved)
+      if (fromStatic && kind === 'import-statement') statics.add(resolved)
     }
   }
   return out