@vzn/vx 0.0.650 → 0.0.651

package/src/report/forecast.ts

@@ -12,8 +12,6 @@ export interface LiveForecast {
   critical?: string
   /** Tasks not started because a dependency has not finished: the tasks line's `blocked`. */
   waiting: number
-  /** Each running task's p50, where history knows it: the row's expected duration. */
-  expected?: ReadonlyMap<string, number>
   /**
    * Tasks not started because a dependency has not finished, in the order
    * the scheduler would start them, at most one per worker: what an idle
@@ -21,13 +19,12 @@ export interface LiveForecast {
    */
   blocked?: readonly BlockedTask[]
   /**
-   * Each running task's count of the tasks downstream of it (a group,
-   * which runs nothing, looked through): its row's `blocks` cell, why they
-   * are not running. A task downstream of two running tasks counts under both.
+   * Each running task's count of what is downstream of it, the
+   * scheduler's own count (`computeReverseDepCount`): its row's `blocks`
+   * cell, why they are not running. A node downstream of two running tasks
+   * counts under both.
    */
   blockedBy: ReadonlyMap<string, number>
-  /** Each task's usual time (its executed p50), for the results' `±usual`. */
-  usual?: ReadonlyMap<string, number>
 }
 
 /** A task an unfinished dependency holds back, and what holds it: the running task its longest chain waits on, else that dependency. */
@@ -54,8 +51,8 @@ export function createForecast(
   nodes: ReadonlyMap<string, TaskNode>,
   p50s: ReadonlyMap<string, number>,
   concurrency: number,
-  /** Each task's count of the tasks downstream of it (`blocksCounts`); computed here when absent. */
-  downstream: ReadonlyMap<string, number> = blocksCounts(nodes),
+  /** Every node's dependents count, the scheduler's baseline and the rows' `blocks`; computed here when absent. */
+  rank: ReadonlyMap<string, number> = computeReverseDepCount(nodes),
 ): Forecast {
   // Dependencies before dependents, once: each call is one pass over it.
   const order: TaskNode[] = []
@@ -87,9 +84,8 @@ export function createForecast(
     if (p !== undefined) cost.set(n.id, p)
   }
   const workers = Math.max(1, concurrency)
-  // The scheduler's own baseline ranking, most dependents first, ties in
-  // graph order: once per run, as the scheduler computes it.
-  const rank = computeReverseDepCount(nodes)
+  // The scheduler's own baseline ranking (`rank`), most dependents first,
+  // ties in graph order.
   const position = new Map(order.map((n, i) => [n.id, i]))
   const before = (a: string, b: string): boolean => {
     const d = (rank.get(a) ?? 0) - (rank.get(b) ?? 0)
@@ -97,12 +93,7 @@ export function createForecast(
   }
 
   return (finished, running, nowMs) => {
-    const expected = new Map<string, number>()
     let waiting = 0
-    for (const id of running.keys()) {
-      const p = cost.get(id)
-      if (p !== undefined) expected.set(id, p)
-    }
     const end = new Map<string, number>()
     // The running task each node's longest chain waits on.
     const head = new Map<string, string>()
@@ -153,30 +144,17 @@ export function createForecast(
       work += own
     }
     for (const id of running.keys()) {
-      const d = downstream.get(id)
+      const d = rank.get(id)
       if (d !== undefined && d > 0) blockedBy.set(id, d)
     }
-    if (!known) return { waiting, expected, blocked: held, blockedBy, usual: cost }
+    if (!known) return { waiting, blocked: held, blockedBy }
     const critical = chainEnd === undefined ? undefined : head.get(chainEnd)
     return {
       etaMs: Math.max(chain, work / workers),
       ...(critical !== undefined ? { critical } : {}),
       waiting,
-      expected,
       blocked: held,
       blockedBy,
-      usual: cost,
     }
   }
 }
-
-/**
- * Each task's `blocks`: how many tasks, a group's own looked through and
- * none counted, sit downstream of it in the run, each once (2026-10-29:
- * every task it holds back, not only the next ones).
- */
-export function blocksCounts(nodes: ReadonlyMap<string, TaskNode>): Map<string, number> {
-  const tasks = new Map<string, true>()
-  for (const n of nodes.values()) if (!isGroupTask(n)) tasks.set(n.id, true)
-  return computeReverseDepCount(nodes, tasks)
-}