@vzn/vx 0.0.334 → 0.0.336

package/README.md

@@ -205,6 +205,8 @@ machine.
 | [`@vzn/vx-mcp`](packages/vx-mcp)                           | `vx mcp`: a read-only MCP server for AI coding agents                         |
 | [`@vzn/vx-schedule-history`](packages/vx-schedule-history) | Schedule by the critical path learned from past runs                          |
 
+Only `@vzn/vx` is on npm today; the plugins' first publish is pending.
+
 Write your own: [plugin guide](https://vznjs.github.io/vx/guides/plugins/) ·
 [architecture](packages/vx/docs/architecture.md).
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vzn/vx",
-  "version": "0.0.334",
+  "version": "0.0.336",
   "description": "A fast, correct task runner and build cache for JavaScript monorepos.",
   "type": "module",
   "exports": {
@@ -21,10 +21,10 @@
     "node": ">=18"
   },
   "optionalDependencies": {
-    "@vzn/vx-linux-x64": "0.0.334",
-    "@vzn/vx-linux-arm64": "0.0.334",
-    "@vzn/vx-darwin-x64": "0.0.334",
-    "@vzn/vx-darwin-arm64": "0.0.334"
+    "@vzn/vx-linux-x64": "0.0.336",
+    "@vzn/vx-linux-arm64": "0.0.336",
+    "@vzn/vx-darwin-x64": "0.0.336",
+    "@vzn/vx-darwin-arm64": "0.0.336"
   },
   "dependencies": {
     "@anthropic-ai/sandbox-runtime": "^0.0.76"

package/src/orchestrator/persistent.ts

@@ -25,8 +25,8 @@ export interface KeepAlive {
 /**
  * A persistent task the user REQUESTED (or one surfaced for display) is the
  * run's whole purpose — it is left running and blocked on at the very end,
- * after the summary. So is every persistent task a kept one depends on,
- * directly or through groups: `vx run dev --filter app` stopped the api#dev
+ * after the summary. So is every persistent task a requested group stands
+ * for, and every one a kept one depends on, directly or through groups: `vx run dev --filter app` stopped the api#dev
  * its app#dev was started against (C-46). A one-shot's persistent deps are
  * not kept on its account; it has finished with them. Only in the real CLI
  * foreground: a custom logger or `handleSignals: false` (watch mode,
@@ -38,11 +38,15 @@ export function selectKeepAlive(
   foreground: boolean,
 ): KeepAlive {
   const out: KeepAlive = { nodes: [], children: [] }
-  if (!foreground) return out
-  const stack = [...registry.keys()].filter((id) => {
-    const n = nodes.get(id)
-    return n !== undefined && (n.requested || n.surfaced === true)
-  })
+  if (!foreground || registry.size === 0) return out
+  // A requested GROUP is a requested server's stand-in: `vx run app#dev`
+  // over `dev: { dependsOn: ['^dev'] }` started every server and exited 0
+  // at the end of the graph, stopping them all (C-52).
+  const stack: string[] = []
+  for (const [id, n] of nodes) {
+    if (!n.requested && n.surfaced !== true) continue
+    if (registry.has(id) || isGroupTask(n)) stack.push(id)
+  }
   const reached = new Set<string>()
   while (stack.length > 0) {
     const id = stack.pop()!

package/src/orchestrator/projects.ts

@@ -7,7 +7,7 @@
 import path from 'node:path'
 import type { ProjectConfig } from '../config.js'
 import {
-  frozenProjectConfig,
+  frozenProjectConfigs,
   loadProjectConfigs,
   validateProjectConfig,
   type LoadProjectConfigOptions,
@@ -216,7 +216,7 @@ export async function loadProjects(args: LoadProjectsArgs): Promise<LoadedProjec
         typeof m.configPath === 'string' && args.staged?.get(m.name) === undefined,
     )
     const loaded = lock
-      ? await Promise.all(withFile.map((m) => frozenProjectConfig(lock, m, workspaceRoot)))
+      ? await frozenProjectConfigs(lock, withFile, workspaceRoot, args.evalCache?.store)
       : await loadProjectConfigs(
           withFile.map((m) => m.configPath),
           args.evalCache !== undefined ? { evalCache: args.evalCache } : {},

package/src/workspace/index.ts

@@ -18,7 +18,7 @@ export {
 export { computeNestedProjectDirs } from './nested-dirs.js'
 export { buildPackageGraph, type PackageGraph } from './package-graph.js'
 export {
-  frozenProjectConfig,
+  frozenProjectConfigs,
   LOCKFILE_NAME,
   LOCKFILE_VERSION,
   lockfilePath,

package/src/workspace/lockfile.ts

@@ -16,7 +16,9 @@
 import { rename, rm } from 'node:fs/promises'
 import path from 'node:path'
 import type { ProjectConfig } from '../config.js'
-import { relPosix, UserError } from '../util/index.js'
+import { relPosix, UserError, xxh3 } from '../util/index.js'
+import { VERSION } from '../version.js'
+import { CONFIG_EVAL_VERSION, type ConfigEvalStore } from './config-cache.js'
 import { validateProjectConfig } from './config-schema.js'
 
 export const LOCKFILE_NAME = 'vx-lock.json'
@@ -54,8 +56,10 @@ export async function readLockfile(root: string): Promise<Lockfile | null> {
   const file = Bun.file(lockfilePath(root))
   if (!(await file.exists())) return null
   let parsed: unknown
+  let text: string
   try {
-    parsed = JSON.parse(await file.text())
+    text = await file.text()
+    parsed = JSON.parse(text)
   } catch {
     throw new UserError(`${LOCKFILE_NAME} is not valid JSON — re-run \`vx lock\` or delete it`)
   }
@@ -95,9 +99,13 @@ export async function readLockfile(root: string): Promise<Lockfile | null> {
       throw new UserError(`${LOCKFILE_NAME}: entry for "${name}" is malformed — re-run \`vx lock\``)
     }
   }
+  lockDigests.set(parsed, xxh3(text).toString(16))
   return parsed as Lockfile
 }
 
+/** The digest of the bytes each lock `readLockfile` returned was parsed from. */
+const lockDigests = new WeakMap<object, string>()
+
 export async function writeLockfile(root: string, lock: Lockfile): Promise<void> {
   // Written beside its name and renamed over it: `Bun.write` truncates in
   // place, so a `--frozen` run, or `vx watch --frozen` woken by the write
@@ -123,26 +131,36 @@ export async function writeLockfile(root: string, lock: Lockfile): Promise<void>
 
 /**
  * Run-time config load from the lock: return the FROZEN resolved config
- * for a project the lock has an entry for. No evaluation happens — this
- * is the fast, eval-free trust path — and no staleness check either (see
- * below): the lock's contract is "what runs is what was locked", so a
- * config file edited since `vx lock` still runs as locked until
- * `vx lock --check` says otherwise. An unlocked project is a hard error;
- * silently falling back to evaluation would break frozen-env semantics.
+ * for each project, in order. No evaluation happens — this is the fast,
+ * eval-free trust path — and no staleness check either (see below): the
+ * lock's contract is "what runs is what was locked", so a config file
+ * edited since `vx lock` still runs as locked until `vx lock --check`
+ * says otherwise. An unlocked project is a hard error; silently falling
+ * back to evaluation would break frozen-env semantics.
+ *
+ * `store` remembers which entries of which lock bytes this validator
+ * accepted, beside the config evaluations and keyed like them (vx's and
+ * Bun's versions): validating 1,000 entries was ~30 ms of every warm
+ * `--frozen` run, for a verdict that cannot change until the bytes or vx
+ * do.
  */
-export async function frozenProjectConfig(
+export async function frozenProjectConfigs(
   lock: Lockfile,
-  meta: { name: string; configPath: string },
+  metas: ReadonlyArray<{ name: string; configPath: string }>,
   root: string,
-): Promise<ProjectConfig> {
-  const rel = relPosix(root, meta.configPath)
-  const entry = lock.projects[meta.name]
-  if (!entry || entry.configPath !== rel) {
-    throw new UserError(
-      `${LOCKFILE_NAME} has no entry for "${meta.name}" (${rel}) — ` +
-        `run \`vx lock\` to refresh, or delete ${LOCKFILE_NAME}`,
-    )
-  }
+  store?: ConfigEvalStore,
+): Promise<ProjectConfig[]> {
+  const entries = metas.map((meta) => {
+    const rel = relPosix(root, meta.configPath)
+    const entry = lock.projects[meta.name]
+    if (!entry || entry.configPath !== rel) {
+      throw new UserError(
+        `${LOCKFILE_NAME} has no entry for "${meta.name}" (${rel}) — ` +
+          `run \`vx lock\` to refresh, or delete ${LOCKFILE_NAME}`,
+      )
+    }
+    return entry
+  })
   // No staleness checks here, deliberately: --frozen runs after
   // `vx lock --check` in any sane pipeline, and that audit re-
   // evaluates everything — a per-file byte-hash re-check would be
@@ -151,6 +169,30 @@ export async function frozenProjectConfig(
   // in the file solely for --check's fast file-changed reporting.
   // The lock is hand-editable; the stored config crosses the same
   // boundary a freshly evaluated one does.
-  validateProjectConfig(entry.config, `${LOCKFILE_NAME} (${meta.name})`)
-  return entry.config
+  const digest = store === undefined ? undefined : lockDigests.get(lock)
+  const keys =
+    digest === undefined
+      ? undefined
+      : metas.map(
+          (m) =>
+            `vx-lock-valid-v${CONFIG_EVAL_VERSION}\0${VERSION}\0${Bun.version}\0${digest}\0${m.name}`,
+        )
+  const known =
+    keys === undefined || store === undefined
+      ? new Map<string, string>()
+      : store.getConfigEvals !== undefined
+        ? store.getConfigEvals(keys)
+        : new Map(keys.flatMap((k) => (store.getConfigEval(k) === null ? [] : [[k, '1'] as const])))
+  const accepted: Array<readonly [string, string]> = []
+  for (let i = 0; i < entries.length; i++) {
+    const key = keys?.[i]
+    if (key !== undefined && known.has(key)) continue
+    validateProjectConfig(entries[i]!.config, `${LOCKFILE_NAME} (${metas[i]!.name})`)
+    if (key !== undefined) accepted.push([key, '1'])
+  }
+  if (store !== undefined && accepted.length > 0) {
+    if (store.putConfigEvals !== undefined) store.putConfigEvals(accepted)
+    else for (const [k, v] of accepted) store.putConfigEval(k, v)
+  }
+  return entries.map((e) => e.config)
 }