@vzn/vx 0.0.645 → 0.0.646

package/src/workspace/project-loader.ts

@@ -14,6 +14,7 @@ import {
 } from './config-eval.js'
 import { configImports, hasEsmExport, unprovidedBareImports } from './config-imports.js'
 import { readOnce, unreadable } from './load-reads.js'
+import { buildCompiled, loadCompiled, loadedModules } from './config-bytecode.js'
 
 // The validator lives in config-schema.ts; re-exported so a reader that
 // reaches the loader for it (the tests do) keeps working.
@@ -142,6 +143,8 @@ async function loadDefaultExport(
   configPath: string,
   kind: string,
   bytes: Uint8Array,
+  /** The workspace root, where the load may run the config's bytecode bundle (config-bytecode.ts). */
+  compiledRoot?: string,
 ): Promise<unknown> {
   refuseUnprovidedImports(bytes, configPath, kind)
   // No random bust for `vx lock`: a project config reaches this import
@@ -166,9 +169,17 @@ async function loadDefaultExport(
     holdSource(hash, source)
   }
   let ns: { default?: unknown }
+  let compiled: { default?: unknown } | null | undefined
+  let loaded: Set<string> | undefined
   const unguard = guardExit()
   let deadline: ReturnType<typeof setTimeout> | undefined
   try {
+    // A bundle that throws is evaluated from source below, so the error
+    // the user sees is the source's.
+    compiled =
+      literal || compiledRoot === undefined ? null : tryCompiled(compiledRoot, configPath, bytes)
+    if (compiled) return defaultOf(compiled, kind, configPath)
+    if (compiled === undefined) loaded = loadedModules(compiledRoot!)
     // The worker's budget, here too: a top-level await that never settled
     // while a timer kept the loop alive hung `vx run` for good, silently
     // (D-66).
@@ -198,11 +209,32 @@ async function loadDefaultExport(
     unguard()
     if (source !== null) releaseSource(hash)
   }
+  const mod = defaultOf(ns, kind, configPath)
+  if (compiledRoot !== undefined && loaded !== undefined) {
+    await buildCompiled(compiledRoot, configPath, bytes, loaded, ns)
+  }
+  return mod
+}
+
+function defaultOf(ns: { default?: unknown }, kind: string, configPath: string): unknown {
   const mod = ns?.default
   assertDefaultObject(mod, kind, configPath)
   return mod
 }
 
+/** The bundle's namespace; `undefined` to build one after this load, `null` when none can serve. */
+function tryCompiled(
+  root: string,
+  configPath: string,
+  bytes: Uint8Array,
+): { default?: unknown } | null | undefined {
+  try {
+    return loadCompiled(root, configPath, bytes)
+  } catch {
+    return null
+  }
+}
+
 /**
  * A config's `process.exit` ended vx mid-load: `exit(0)` was a green run
  * that ran nothing and printed nothing (D-65). While any config evaluates
@@ -509,12 +541,53 @@ export async function loadProjectConfigs(configPaths: readonly string[]): Promis
 let redirectHolders = 0
 let undoRedirect = (): void => {}
 /**
- * Bun's own `Console`, taken at load: the console a round finds may be a
- * constructed one (a plugin's verb may install its own), which has no `Console`.
- * The global's, not `node:console`'s: the playground bundles this module
- * for the browser, where that specifier is a stub.
+ * Bun's own console, taken at load: the console a round finds may be a
+ * constructed one (a plugin's verb may install its own), which has no
+ * `Console`. The global's, not `node:console`'s: the playground bundles
+ * this module for the browser, where that specifier is a stub.
  */
-const BunConsole = (globalThis.console as { Console?: typeof console.Console }).Console
+const bunConsole = globalThis.console as typeof console & { Console?: typeof console.Console }
+let stderrConsole: typeof console | undefined
+const BUILT_ON_READ: ReadonlySet<PropertyKey> = new Set(['Console', '_stdout', '_stderr'])
+
+/**
+ * A console that writes to stderr, built on the first call: reading
+ * `Console` loads `node:console`, ~4 ms of a warm run, and the workspace
+ * config each run loads in a redirect seldom prints.
+ */
+function redirectedConsole(): typeof console {
+  const real = (): Record<PropertyKey, (...a: unknown[]) => unknown> =>
+    (stderrConsole ??= Object.assign(new bunConsole.Console!(process.stderr, process.stderr), {
+      // Bun's console adds `write`, which a constructed Console lacks.
+      write: (...data: string[]) => {
+        const text = data.join('')
+        process.stderr.write(text)
+        return text.length
+      },
+    })) as unknown as Record<PropertyKey, (...a: unknown[]) => unknown>
+  const facade = {}
+  for (const key of [...Reflect.ownKeys(bunConsole), 'write']) {
+    // Read through the real one when read: even their descriptors build a
+    // module or a stream (~17 ms together, Bun 1.4.2).
+    if (BUILT_ON_READ.has(key)) {
+      Object.defineProperty(facade, key, { get: () => real()[key], configurable: true })
+      continue
+    }
+    const own = Object.getOwnPropertyDescriptor(bunConsole, key)
+    Object.defineProperty(
+      facade,
+      key,
+      own === undefined || typeof own.value === 'function'
+        ? {
+            value: (...args: unknown[]) => real()[key]!(...args),
+            writable: true,
+            configurable: true,
+          }
+        : own,
+    )
+  }
+  return facade as typeof console
+}
 
 function stdoutToStderr(): () => void {
   if (redirectHolders++ === 0) undoRedirect = installRedirect()
@@ -540,14 +613,7 @@ function installRedirect(): () => void {
   ;(Bun.stdout as { writer: typeof Bun.stdout.writer }).writer = ((
     ...args: Parameters<typeof Bun.stderr.writer>
   ) => Bun.stderr.writer(...args)) as typeof Bun.stdout.writer
-  // Bun's console adds `write`, which a constructed Console lacks.
-  globalThis.console = Object.assign(new BunConsole!(process.stderr, process.stderr), {
-    write: (...data: string[]) => {
-      const text = data.join('')
-      process.stderr.write(text)
-      return text.length
-    },
-  })
+  globalThis.console = redirectedConsole()
   return () => {
     if (ownWrite === undefined) delete (out as { write?: unknown }).write
     else Object.defineProperty(out, 'write', ownWrite)
@@ -622,12 +688,14 @@ interface BuiltinSnapshot {
  */
 const BUN_MEMBERS_VX_READS: readonly PropertyKey[] = [
   'Archive',
+  'BuildMetafile',
   'BunFile',
   'CryptoHasher',
   'Glob',
   'JSONC',
   'Subprocess',
   'Transpiler',
+  'build',
   'color',
   'deepEquals',
   'env',
@@ -637,9 +705,11 @@ const BUN_MEMBERS_VX_READS: readonly PropertyKey[] = [
   'inspect',
   'main',
   'nanoseconds',
+  'pathToFileURL',
   'plugin',
   'randomUUIDv7',
   'resolveSync',
+  'revision',
   'secrets',
   'serve',
   'sleep',
@@ -959,7 +1029,15 @@ export async function loadWorkspaceConfig(root: string): Promise<WorkspaceConfig
     const umask = currentUmask()
     let mod: WorkspaceConfig
     try {
-      mod = (await loadDefaultExport(configPath, 'Workspace', bytes)) as WorkspaceConfig
+      mod = (await loadDefaultExport(
+        configPath,
+        'Workspace',
+        bytes,
+        // Every load, not only the first: a repeat load (the run after the
+        // CLI's selection pass) must get the same plugin instances, and a
+        // required bundle is the cached module.
+        path.resolve(root),
+      )) as WorkspaceConfig
     } finally {
       const changed = [
         ...restoreBuiltins(builtins),