@vzn/vx 0.0.652 → 0.0.653

package/src/orchestrator/deferred-outputs.ts

@@ -20,6 +20,9 @@ import {
   type GitFilesCache,
 } from '../cache/index.js'
 import type { TaskNode } from '../graph/index.js'
+import { type Logger, warnOf } from '../report/index.js'
+import type { CommandWindows } from './command-windows.js'
+import { bracketLiteralHint } from './miss-save.js'
 
 export interface DeferredEntry {
   /** Fetches this task's outputs onto disk. At-most-once by construction. */
@@ -33,10 +36,14 @@ export interface DeferredOutputsArgs {
   nodes: Map<string, TaskNode>
   cache: CacheLayer
   workspaceRoot: string
-  nestedDirsByProject: Map<string, string[]>
+  /** Where each project's outputs stop (prepare.ts `outputWallsOf`). */
+  nestedDirsByProject: ReadonlyMap<string, string[]>
   gitFilesCache?: GitFilesCache
   /** False when the run's policy writes no local entries. */
   localWrite: boolean
+  log: Logger
+  /** The run's command windows: a fetch writes into the tree as a restore does. */
+  commandWindows?: CommandWindows
 }
 
 export class DeferredOutputs {
@@ -121,6 +128,11 @@ export class DeferredOutputs {
       projectDir: producer.projectDir,
       outputs,
       nestedProjectDirs,
+      inputs: {
+        projectDir: producer.projectDir,
+        workspaceRoot: this.args.workspaceRoot,
+        declared: producer.config.inputs,
+      },
       committed: committedFiles(this.args.gitFilesCache, producer.projectDir),
     }
 
@@ -131,18 +143,26 @@ export class DeferredOutputs {
     // reader of these outputs can be in the run — `deferralEligibility`
     // keeps every same-project reader and every workspaceFiles reader
     // eager — so deleting the post-fetch mark survives the whole core
-    // suite (item 643).
-    if (outputs.length > 0) {
-      const cleaned = await cleanOutputs(cleanArgs)
-      this.args.gitFilesCache?.markOutputsChanged(producer.projectDir, cleaned)
-    }
+    // suite (item 643). In a window, as a hit's restore (hit-restore.ts):
+    // without one, `vx watch` took the fetched outputs for the user's edit
+    // and ran one more cycle.
+    const closeWindow =
+      this.args.commandWindows?.open(taskId, producer.projectDir, 'project') ?? (() => {})
     try {
-      await entry.materialize()
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err)
-      throw new Error(
-        `could not fetch deferred outputs of ${taskId}: ${msg} — re-run it with --force, or use --cache-download=all`,
-      )
+      if (outputs.length > 0) {
+        const cleaned = await cleanOutputs(cleanArgs)
+        this.args.gitFilesCache?.markOutputsChanged(producer.projectDir, cleaned)
+      }
+      try {
+        await entry.materialize()
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err)
+        throw new Error(
+          `could not fetch deferred outputs of ${taskId}: ${msg} — re-run it with --force, or use --cache-download=all`,
+        )
+      }
+    } finally {
+      closeWindow()
     }
     const { files: outputFiles, emptyDirs } = await resolveOutputTree(cleanArgs)
     this.args.gitFilesCache?.markOutputsChanged(
@@ -153,6 +173,15 @@ export class DeferredOutputs {
     // and nothing downstream learns a second shape. Policy still governs —
     // a run that writes no local entries writes none here either.
     if (this.args.localWrite && entry.hash !== undefined) {
+      // The eager save's warning: a fetch that landed nothing under the
+      // declared outputs saves an empty artifact the next run replays.
+      if (outputs.length > 0 && outputFiles.length === 0) {
+        warnOf(this.args.log)(
+          `[vx] ${taskId}: outputs matched no files (${outputs.join(', ')}) — ` +
+            `an empty artifact is saved; a later hit restores nothing` +
+            bracketLiteralHint(outputs.map((g) => [producer.projectDir, g] as const)),
+        )
+      }
       await this.args.cache.save({
         hash: entry.hash,
         projectDir: producer.projectDir,

package/src/orchestrator/doctor.ts

@@ -20,6 +20,7 @@ import {
   machineParallelism,
   treeBytes,
 } from '../util/index.js'
+import { isDefaultBuild } from '../graph/index.js'
 import * as ui from '../ui/index.js'
 import { vxPath } from '../handoff.js'
 import { VERSION } from '../version.js'
@@ -105,14 +106,17 @@ export interface InfoFacts {
   cacheIndexError: string | null
   /**
    * Every setting (src/settings.ts) as a run with no flags takes it: its
-   * variable's value, else the workspace's (after the `config` stage),
+   * variable's value, else the workspace's (after the `config` stage;
+   * source `plugin`, naming it, when a plugin's `config` hook set it),
    * else null with source `default` (docs/schema.md names each default).
    */
   settings: Record<
     string,
     {
       value: string | number | boolean | null
-      source: 'env' | 'workspace' | 'default'
+      source: 'env' | 'workspace' | 'plugin' | 'default'
+      /** The plugin whose `config` hook set it, with source `plugin`. */
+      plugin?: string
       /** Why a run refuses this variable's value; absent when it takes it. */
       refused?: string
     }
@@ -199,7 +203,7 @@ async function collectInfoChecked(cwd: string, opts: CollectInfoOptions): Promis
 async function collectWorkspaceInfo(
   cwd: string,
   root: string,
-  { workspaceConfig, plugins }: Awaited<ReturnType<typeof loadWorkspacePlugins>>,
+  { workspaceConfig, plugins, settingPlugins }: Awaited<ReturnType<typeof loadWorkspacePlugins>>,
   opts: CollectInfoOptions,
   probing: Promise<Omit<InfoFacts['sandbox'], 'declared'>>,
 ): Promise<InfoFacts> {
@@ -274,7 +278,9 @@ async function collectWorkspaceInfo(
     })
     for (const p of loaded.projects.values()) {
       const tasks = p.config.tasks ?? {}
-      taskCount += Object.keys(tasks).length
+      // The default build is no declared task: `vx run build` denies it, and
+      // right after `vx init` the doctor said `1 (1 task)` of `tasks: {}`.
+      taskCount += Object.values(tasks).filter((t) => !isDefaultBuild(t)).length
       for (const t of Object.values(tasks)) if (t?.exec?.sandbox !== undefined) sandboxed++
     }
   } catch (err) {
@@ -332,7 +338,7 @@ async function collectWorkspaceInfo(
     cacheEntries: stats.entryCount,
     cacheBytes: stats.totalBytes,
     cacheIndexError: indexError,
-    settings: settingsFact(workspaceConfig),
+    settings: settingsFact(workspaceConfig, settingPlugins),
     // A row-less artifact is indexed again only when its task asks for its
     // key; the rest only `vx cache clean` reclaims (after an upgrade's
     // schema reset, most often).
@@ -469,17 +475,23 @@ function gitVersion(): string | null {
   }
 }
 
-function settingsFact(config: WorkspaceConfig | null): InfoFacts['settings'] {
+function settingsFact(
+  config: WorkspaceConfig | null,
+  settingPlugins: ReadonlyMap<string, string>,
+): InfoFacts['settings'] {
   const out: InfoFacts['settings'] = {}
   for (const s of SETTINGS) {
     const env = s.env === false ? undefined : process.env[envName(s.path)]
     const declared = s.config === false ? undefined : atPath(config, s.path)
+    const plugin = settingPlugins.get(s.path)
     out[s.path] =
       env !== undefined && env !== ''
         ? { value: env, source: 'env' }
-        : declared !== undefined
-          ? { value: declared as string | number | boolean, source: 'workspace' }
-          : { value: null, source: 'default' }
+        : declared === undefined
+          ? { value: null, source: 'default' }
+          : plugin !== undefined
+            ? { value: declared as string | number | boolean, source: 'plugin', plugin }
+            : { value: declared as string | number | boolean, source: 'workspace' }
   }
   return out
 }

package/src/orchestrator/download-policy.ts

@@ -141,8 +141,8 @@ function prefixesOverlap(a: string, b: string): boolean {
 export function resolveDownloadModes(args: {
   nodes: Map<string, TaskNode>
   policy: 'all' | 'toplevel' | 'none'
-  /** Task ids placed on a LOCAL executor — they write in place. */
-  localPlaced: ReadonlySet<string>
+  /** Placed on a LOCAL executor: it writes in place. */
+  localPlaced: (id: string) => boolean
   /** Task ids with `exec.remote: 'only'`. */
   remoteOnly: ReadonlySet<string>
 }): { modeOf: Map<string, DownloadMode>; downgrades: Map<string, string> } {
@@ -156,7 +156,7 @@ export function resolveDownloadModes(args: {
       modeOf.set(n.id, 'never')
       continue
     }
-    if (args.policy === 'all' || args.localPlaced.has(n.id)) {
+    if (args.policy === 'all' || args.localPlaced(n.id)) {
       modeOf.set(n.id, 'eager')
       continue
     }

package/src/orchestrator/excluded-keys.ts

@@ -14,7 +14,13 @@
 // full run looks up.
 
 import type { CacheLayer, GitFilesCache } from '../cache/index.js'
-import { isGroupTask, keyedDeps, type TaskNode, type TaskOutcome } from '../graph/index.js'
+import {
+  isGroupTask,
+  keyedDeps,
+  standInsOf,
+  type TaskNode,
+  type TaskOutcome,
+} from '../graph/index.js'
 import { computeGroupKey, computeTaskHash, type HashCache } from './task-hash.js'
 import { filterUpstreamHashes, keyedOutcome } from './upstream.js'
 
@@ -133,6 +139,12 @@ function foldsExcludedKey(node: TaskNode): boolean {
   if (excluded === undefined) return false
   if (isGroupTask(node)) return true
   return (
-    filterUpstreamHashes(excluded, node.config.inputs?.tasks, node.projectName, node.id).length > 0
+    filterUpstreamHashes(
+      excluded,
+      node.config.inputs?.tasks,
+      node.projectName,
+      node.id,
+      standInsOf(node),
+    ).length > 0
   )
 }

package/src/orchestrator/execute-args.ts

@@ -10,6 +10,7 @@ import type { DownloadMode } from './download-policy.js'
 import type { ExecuteArgs } from './execute-task.js'
 import type { ShortCircuit } from './local-shortcircuit.js'
 import { UNPLACED_EXECUTOR, type Placements } from './placement.js'
+import { outputWallsOf } from './prepare.js'
 
 type TaskField =
   | 'node'
@@ -17,7 +18,9 @@ type TaskField =
   | 'log'
   | 'executor'
   | 'nestedProjectDirs'
+  | 'outputNestedDirs'
   | 'remoteOnlyNoop'
+  | 'belowNoop'
   | 'remoteOnly'
   | 'download'
   | 'preProbed'
@@ -35,7 +38,8 @@ export interface TaskFacts {
   log: (node: TaskNode) => Logger
   placements: Placements
   nestedDirsByProject: ReadonlyMap<string, string[]>
-  downloadModeOf: ReadonlyMap<string, DownloadMode>
+  /** None under `cache.download: all`: every task eager. */
+  downloadModeOf: ReadonlyMap<string, DownloadMode> | undefined
   shortCircuit: Pick<ShortCircuit, 'preProbed' | 'uncachedKeys' | 'groupKeys'>
   /** Tasks some other task depends on. */
   dependedOn: ReadonlySet<string>
@@ -53,6 +57,7 @@ export function executeArgsOf(
   facts: TaskFacts,
 ): (node: TaskNode, upstream: TaskOutcome[], reuseProbe: boolean, tainted: boolean) => ExecuteArgs {
   const { placements, shortCircuit } = facts
+  const walls = outputWallsOf(facts.nestedDirsByProject)
   return (node, upstream, reuseProbe, tainted) => {
     const id = node.id
     const a: ExecuteArgs = {
@@ -66,8 +71,10 @@ export function executeArgsOf(
     const probe = reuseProbe ? shortCircuit.preProbed.get(id) : undefined
     const upfrontKey = shortCircuit.uncachedKeys.get(id)
     const upfrontGroupKey = shortCircuit.groupKeys.get(id)
-    if (facts.downloadModeOf.get(id) === 'deferred') a.download = 'deferred'
+    if (walls !== facts.nestedDirsByProject) a.outputNestedDirs = walls.get(node.projectName) ?? []
+    if (facts.downloadModeOf?.get(id) === 'deferred') a.download = 'deferred'
     if (placements.remoteOnlyNoop.has(id)) a.remoteOnlyNoop = true
+    if (placements.belowNoop.has(id)) a.belowNoop = true
     if (placements.remoteOnly.has(id)) a.remoteOnly = true
     if (placements.carried.has(id)) a.carried = true
     const servers = placements.servers.get(id)