@vzn/vx 0.0.618 → 0.0.619

package/package.json

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

package/src/orchestrator/prepare.ts

@@ -189,6 +189,18 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
   // fingerprint. A watch cycle is a new run and reads it afresh.
   const reads: LoadReads = new Map()
   const workspaceRoot = await findWorkspaceRoot(options.cwd, reads)
+  // A frozen run with nothing staged reads the lock whatever discovery
+  // finds, so the read (1.1 MB at 1,000 projects, ~10 ms to read and
+  // parse) starts here and overlaps discovery's I/O instead of following
+  // the cache open (X-181). A missing or malformed lock still refuses at
+  // the config load, after any earlier refusal.
+  let lockRead: Promise<Lockfile> | undefined
+  const readLock = (): Promise<Lockfile> =>
+    (lockRead ??= readLockfile(workspaceRoot).then((read) => {
+      if (read === null) throw new UserError(FROZEN_WITHOUT_LOCK)
+      return read
+    }))
+  if (options.frozen === true && options.staged === undefined) void readLock().catch(() => {})
   // An UNSCOPED run (no explicit scope, at least one bare task name)
   // enumerates the whole tree whatever the configs say, so git starts
   // HERE — the walk needs only the root — and overlaps the workspace
@@ -313,13 +325,8 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
   // Read once, and only when a config is to be read from it: the CLI's
   // selection pass may have staged every config (`options.staged`), and
   // its load refused a frozen run without a lock. A 1,000-project lock is
-  // 1.1 MB of JSON (I-27).
-  let lockRead: Promise<Lockfile> | undefined
-  const readLock = (): Promise<Lockfile> =>
-    (lockRead ??= readLockfile(workspaceRoot).then((read) => {
-      if (read === null) throw new UserError(FROZEN_WITHOUT_LOCK)
-      return read
-    }))
+  // 1.1 MB of JSON (I-27); a run with nothing staged started its read
+  // beside discovery, above.
   const staged = options.staged
   const allStaged =
     staged !== undefined &&

package/src/workspace/lockfile.ts

@@ -179,13 +179,18 @@ export async function frozenProjectConfigs(
   // The lock is hand-editable; the stored config crosses the same
   // boundary a freshly evaluated one does.
   const digest = store === undefined ? undefined : lockDigests.get(lock)
-  const keys =
+  const prefix =
     digest === undefined
       ? undefined
-      : metas.map(
-          (m) =>
-            `vx-lock-valid-v${CONFIG_EVAL_VERSION}\0${VERSION}\0${Bun.version}\0${digest}\0${m.name}`,
-        )
+      : `vx-lock-valid-v${CONFIG_EVAL_VERSION}\0${VERSION}\0${Bun.version}\0${digest}`
+  // One row for a lock whose every entry was accepted: a warm `--all` run
+  // asked for 1,090 per-project rows in one `IN` query, ~10 ms of its
+  // config load, where the eval-cache path it replaces is cheaper (X-181).
+  // A scoped run still validates, and remembers, only what it loads.
+  if (prefix !== undefined && store !== undefined && store.getConfigEval(prefix) !== null) {
+    return entries.map((e) => e.config)
+  }
+  const keys = prefix === undefined ? undefined : metas.map((m) => `${prefix}\0${m.name}`)
   const known =
     keys === undefined || store === undefined
       ? new Map<string, string>()
@@ -199,6 +204,14 @@ export async function frozenProjectConfigs(
     validateProjectConfig(entries[i]!.config, `${LOCKFILE_NAME} (${metas[i]!.name})`)
     if (key !== undefined) accepted.push([key, '1'])
   }
+  // Every meta found its entry above, so as many distinct names as the
+  // lock holds is every entry of it.
+  if (
+    prefix !== undefined &&
+    new Set(metas.map((m) => m.name)).size === Object.keys(lock.projects).length
+  ) {
+    accepted.push([prefix, '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)