@vzn/vx 0.0.651 → 0.0.653

package/src/graph/definition.ts

@@ -15,18 +15,31 @@ const memo = new WeakMap<TaskNode, string | undefined>()
 export function taskDefinition(node: TaskNode): string | undefined {
   if (memo.has(node)) return memo.get(node)
   const exec = node.config.exec
+  const define = exec?.env?.define
   const def =
     exec?.command === undefined
       ? undefined
       : xxh3hex(
-          `${node.id}\0${exec.command}\0${JSON.stringify(
-            Object.entries(exec.env?.define ?? {}).sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0)),
-          )}`,
+          `${node.id}\0${exec.command}\0${
+            // `[]` is what the stringify gives for no values: most tasks
+            // have none, and stringifying it for each was ~9 ms of an
+            // 8,002-hit warm run.
+            define === undefined || isEmpty(define)
+              ? '[]'
+              : JSON.stringify(
+                  Object.entries(define).sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0)),
+                )
+          }`,
         )
   memo.set(node, def)
   return def
 }
 
+function isEmpty(o: object): boolean {
+  for (const _ in o) return false
+  return true
+}
+
 /** Each task's definition (`taskDefinition`) by id, groups left out: what a history reader matches rows to. */
 export function taskDefinitions(nodes: Iterable<TaskNode>): Map<string, string> {
   const out = new Map<string, string>()

package/src/graph/folds.ts

@@ -10,6 +10,7 @@ import {
   parseDependencySpec,
   type DependencySpec,
 } from '../util/index.js'
+import { standInsOf, type StandIns } from './stand-ins.js'
 import type { TaskNode } from './task-graph.js'
 
 /**
@@ -36,9 +37,13 @@ export function keyedDeps(node: TaskNode): readonly string[] {
  * A filter selects among the task's own dependencies, never through a
  * group: `dependsOn: ['build']` over a group `build` of `build.a` and
  * `build.b` offers the filter `build`, not its members. A pattern that
- * matches only a member (`build.*`) therefore selected nothing, and the key stopped moving
- * with that member's inputs: a stale hit under a green run. Such a spec
- * is refused, once, over the graph every key site reads. One that matches
+ * matches a member (`build.*`) the filter folds neither directly nor
+ * through a selected group therefore left it out, and the key stopped
+ * moving with that member's inputs: a stale hit under a green run. That
+ * held when the pattern also matched another dependency directly
+ * (`dependsOn: ['build', 'build.a']`), so such a spec is refused, once,
+ * over the graph every key site reads, unless it matches the group
+ * itself (a negation of the group is a decision). One that matches
  * nothing anywhere stays legal (a preset's pattern needn't match in every
  * project). An exact name is refused earlier, at load, unless `dependsOn`
  * names it (`assertFilterNamesDeclaredDeps`).
@@ -49,20 +54,37 @@ export function refuseFiltersThroughGroups(nodes: ReadonlyMap<string, TaskNode>)
     if (filter === undefined || filter.length === 0) continue
     const deps = keyedDeps(node).flatMap((id) => nodes.get(id) ?? [])
     const groups = deps.filter(isGroupTask)
+    const folded = new Set<TaskNode>()
+    if (groups.length > 0) {
+      const units = deps.map((n) => ({ node: n, unit: n.id }))
+      const picked = selectFoldedDeps(units, filter, node.projectName, node.id, standInsOf(node))
+      for (const { node: n } of picked) {
+        folded.add(n)
+        if (isGroupTask(n)) for (const m of groupMembers(n, nodes)) folded.add(m)
+      }
+    }
     for (const raw of filter) {
       const spec = parseSpec(raw, node.id)
       if (spec.negated) continue
       const matches = specMatcher(spec)
       const hit = (n: TaskNode): boolean => matches(n, n.projectName === node.projectName)
-      if (deps.some(hit)) continue
+      const direct = deps.some(hit)
       for (const group of groups) {
-        const member = groupMembers(group, nodes).find(hit)
+        if (hit(group)) continue
+        const member = groupMembers(group, nodes).find(
+          (m) => hit(m) && !folded.has(m) && !deps.includes(m),
+        )
         if (member === undefined) continue
+        const outcome = direct ? 'so the key leaves it out' : 'so it selects nothing'
         throw new UserError(
-          `${node.id}: inputs.tasks: '${raw}' matches ${member.id} only through the group ${group.id}, so it selects nothing; name '${group.taskName}' or depend on ${member.id} directly`,
+          `${node.id}: inputs.tasks: '${raw}' matches ${member.id} only through the group ${group.id}, ${outcome}; name '${group.taskName}' or depend on ${member.id} directly`,
         )
       }
-      if (namesNoDependency(spec, node.config.dependsOn ?? [])) {
+      if (direct) continue
+      if (
+        namesNoDependency(spec, node.config.dependsOn ?? []) ||
+        namesTransitiveDependency(spec, node, nodes, hit)
+      ) {
         const named = deps.map((d) => d.id).join(', ') || 'none'
         throw new UserError(
           `${node.id}: inputs.tasks: '${raw}' names none of its dependencies (${named}), so it selects nothing and the key would not move with them; fix the name, or use [] to decouple on purpose`,
@@ -100,6 +122,34 @@ function namesNoDependency(spec: DependencySpec, dependsOn: readonly string[]):
   })
 }
 
+/**
+ * An exact `pkg#task` filter that matched no dependency but names a task the
+ * key reaches only through one. `namesNoDependency` lets it through when a
+ * `^` entry names the task (the preset whose project lacks that dependency),
+ * but `a → b → c` with `dependsOn: ['^build']` and `['c#build']` selected
+ * none of a's direct dependencies, and an edit to c replayed a's hit.
+ */
+function namesTransitiveDependency(
+  spec: DependencySpec,
+  node: TaskNode,
+  nodes: ReadonlyMap<string, TaskNode>,
+  hit: (n: TaskNode) => boolean,
+): boolean {
+  if (spec.kind !== 'cross' || isTaskPattern(spec.project) || isTaskPattern(spec.task)) return false
+  const seen = new Set<string>([node.id])
+  const stack = [...keyedDeps(node)]
+  while (stack.length > 0) {
+    const id = stack.pop()!
+    if (seen.has(id)) continue
+    seen.add(id)
+    const n = nodes.get(id)
+    if (n === undefined) continue
+    if (hit(n)) return true
+    stack.push(...keyedDeps(n))
+  }
+  return false
+}
+
 function parseSpec(raw: string, selfTaskId: string): DependencySpec {
   try {
     return parseDependencySpec(raw, 'inputs.tasks')
@@ -162,16 +212,26 @@ export interface FoldCandidate {
  *   - `filter === undefined` → every candidate, as given.
  *   - `filter === []`        → none (fully decoupled).
  *
- * Otherwise deduped by `unit`, first candidate kept. The unit is the
- * fold's own identity, not the task's: two groups over the same members
- * share one hash, so excluding either excludes both, and a selection by
- * task id would keep the other while the key folded neither.
+ * Otherwise deduped by `unit`, first selected candidate kept. The unit is
+ * the fold's own identity, not the task's: two groups over the same members
+ * share one hash. A negation drops only the candidates it names, and the
+ * dedup runs after every entry, so a unit still selected through another
+ * candidate stays folded: deleting by unit let `['^*', '!c#build']` drop
+ * b#build's group with c#build's, and a change beneath both replayed the
+ * old hit.
+ *
+ * `standIns` is the task's `standInsOf`: an edge added past a
+ * default build on a package cycle is selected whenever an edge it went
+ * past is. That build folds nothing of its cycle, so `['build']` on
+ * `a ↔ b` selected a#build alone, dropped b#build, and an edit to b
+ * replayed the old hit.
  */
 export function selectFoldedDeps(
   deps: readonly FoldCandidate[],
   filter: readonly string[] | undefined,
   selfProjectName: string,
   selfTaskId: string,
+  standIns?: StandIns,
 ): FoldCandidate[] {
   if (filter === undefined) return [...deps]
 
@@ -180,18 +240,25 @@ export function selectFoldedDeps(
   // Per-spec predicate, compiled once (exact compares + patterns).
   const matchers = specs.map((spec) => specMatcher(spec))
 
-  const selected = new Map<string, FoldCandidate>()
+  const selected = new Set<FoldCandidate>()
   for (let i = 0; i < specs.length; i++) {
     const spec = specs[i]!
     const matches = matchers[i]!
     for (const d of deps) {
       const isSelf = d.node.projectName === selfProjectName
       if (!matches(d.node, isSelf)) continue
-      if (spec.negated) selected.delete(d.unit)
-      else if (!selected.has(d.unit)) selected.set(d.unit, d)
+      if (spec.negated) selected.delete(d)
+      else selected.add(d)
     }
   }
-  return [...selected.values()]
+  if (standIns !== undefined) {
+    const ids = new Set<string>()
+    for (const d of selected) ids.add(d.node.id)
+    for (const d of deps) if (standIns[d.node.id]?.some((p) => ids.has(p))) selected.add(d)
+  }
+  const byUnit = new Map<string, FoldCandidate>()
+  for (const d of selected) if (!byUnit.has(d.unit)) byUnit.set(d.unit, d)
+  return [...byUnit.values()]
 }
 
 /** Exact-name compare, or the shared `*`-glob when the name is a pattern. */
@@ -250,7 +317,13 @@ export function foldedDeps(node: TaskNode, nodeOf: (id: string) => TaskNode): Fo
     candidates.push({ node: dep, unit: foldUnit(dep) })
   }
   if (isGroupTask(node) && node.config.inputs === undefined) return candidates
-  return selectFoldedDeps(candidates, node.config.inputs?.tasks, node.projectName, node.id)
+  return selectFoldedDeps(
+    candidates,
+    node.config.inputs?.tasks,
+    node.projectName,
+    node.id,
+    standInsOf(node),
+  )
 }
 
 /**

package/src/graph/index.ts

@@ -18,6 +18,7 @@ export {
 } from './folds.js'
 export { DEFAULT_BUILD, isDefaultBuild } from './default-build.js'
 export { computeReverseDepCount } from './priorities.js'
+export { setStandIns, type StandIns, standInsOf } from './stand-ins.js'
 export { criticalPath } from './critical-path.js'
 export { taskDefinition, taskDefinitions } from './definition.js'
 export {
@@ -26,6 +27,13 @@ export {
   idleServers,
   type InputChanges,
   RestoreDemoted,
+  isKeyFailed,
+  KeyFailed,
+  markKeyFailed,
+  markOutputsFailed,
+  OutputsFailed,
+  outputsFailedOf,
+  RestoreFailed,
   runGraph,
   type TaskOutcome,
 } from './scheduler.js'

package/src/graph/priorities.ts

@@ -347,10 +347,14 @@ export function strategyPriorities(
   return out
 }
 
+/**
+ * A task's merged weight, read as asked: a merged copy held an entry per
+ * task of the run beside the two maps it was made of.
+ */
 export function mergePriorities(
   baseline: ReadonlyMap<string, number>,
   overrides: ReadonlyMap<string, number>,
-): ReadonlyMap<string, number> {
+): (id: string) => number {
   // The override caller scored "expected critical-path duration" in ms.
   // Baseline reverse-deps counts are bounded by N; scale the override so
   // it sorts above the baseline for any node it covers, and add the
@@ -361,10 +365,9 @@ export function mergePriorities(
   const SCALE = 1 << 20
   let lo = 0
   for (const w of overrides.values()) if (w < lo) lo = w
-  const out = new Map(baseline)
-  for (const [id, w] of overrides) {
+  return (id) => {
     const b = baseline.get(id) ?? 0
-    out.set(id, (w - lo + 1) * SCALE + b)
+    const w = overrides.get(id)
+    return w === undefined ? b : (w - lo + 1) * SCALE + b
   }
-  return out
 }