@vzn/vx-dte 0.0.652 → 0.0.653

package/src/planner.ts

@@ -18,6 +18,9 @@ import {
 } from './dispatch.js'
 import { DEFAULT_STRATEGY, type Strategy } from './strategy.js'
 
+/** Where a task naming no platform runs, or (several worker types) where each task runs. */
+type Home = string | ((node: TaskNode) => string | undefined)
+
 /**
  * A task's duration when history has none: a test suite's, so a run with
  * no history starts workers for its work rather than one for all of it.
@@ -53,6 +56,8 @@ export interface PlanTask {
   /** Its number in the run's graph and its deps' (`planTasks`): a plan's shape reads them, not ids. */
   readonly n?: number
   readonly depsN?: Int32Array
+  /** Its servers' bases (`Need.servers`): booked once on each worker. */
+  readonly servers?: Need['servers']
 }
 
 /** The run's tasks numbered once, and each one's deps by number. */
@@ -97,6 +102,8 @@ export interface PlanWorker {
   readonly platform?: string | undefined
   /** The size it was started as (`Size.name`): what its warm-up is learned by. */
   readonly size?: string | undefined
+  /** The servers it runs, each with the base booked there. */
+  readonly serving?: ReadonlyMap<string, number> | undefined
 }
 
 /** A worker's warm-up, one for all, or by its size (`Size.name`; none for one that joined on its own). */
@@ -131,14 +138,21 @@ interface Ahead {
   /** When the window it played moves on, from now: plan again then. */
   readonly untilInMs: number | undefined
   readonly freeInMs: ReadonlyMap<string, number>
+  /** The tasks it gives each worker. */
+  readonly given: ReadonlyMap<string, readonly string[]>
   readonly later: readonly {
     readonly size: Size
     readonly inMs: number
     readonly freeInMs: number
     readonly joinInMs: number
+    readonly given: readonly string[]
+  }[]
+  /** For each started now, when its work ends, when it joins and what it runs. */
+  readonly started: readonly {
+    readonly freeInMs: number
+    readonly joinInMs: number
+    readonly given: readonly string[]
   }[]
-  /** For each started now, when its work ends and when it joins. */
-  readonly started: readonly { readonly freeInMs: number; readonly joinInMs: number }[]
 }
 
 /** History the run's finished tasks must have had before `slowdown` says anything. */
@@ -202,7 +216,7 @@ export function planTasks(
   nodes: ReadonlyMap<string, TaskNode>,
   need: (id: string) => Need,
   durationMs: (id: string) => number | undefined,
-  home?: string,
+  home?: Home,
 ): PlanTask[] {
   // The graph is the run's, fixed: each task is numbered and its deps
   // walked once a run, not at each plan (2026-11-05: a 5000-task sim
@@ -247,9 +261,10 @@ export function planTasks(
       above: n.above,
       ms: durationMs(id),
       deps,
-      platform: e.node.platform ?? home,
+      platform: typeof home === 'function' ? home(e.node) : (e.node.platform ?? home),
       n: e.n,
       depsN: e.depsN,
+      ...(n.servers === undefined ? {} : { servers: n.servers }),
     })
   }
   return out
@@ -272,7 +287,7 @@ export function missedWork(
   executed: ReadonlySet<string>,
   need: (id: string) => Need,
   durationMs: (id: string) => number | undefined,
-  home?: string,
+  home?: Home,
 ): PlanTask[] {
   const changed = new Map<string, boolean>()
   // Whether `id`'s key changed: a cached task that missed, or one after it.
@@ -294,6 +309,43 @@ export function missedWork(
   return planTasks([...remaining].filter(missed), nodes, need, durationMs, home)
 }
 
+/**
+ * `workers` as a plan may let them go: of a platform whose sizes can start
+ * no other (`max` spent; one let go still counts), the last idle one stays
+ * while a task of that platform has not ended (`left`). A hit core's probe
+ * found can still miss when its restore fails, and only a worker of its
+ * platform runs it: main let its one arm worker go, check.binary.linux-arm64
+ * came back as a miss, and the run waited out its timeout (2026-11-06).
+ */
+export function keepLast(
+  workers: readonly PlanWorker[],
+  sizes: readonly Size[],
+  started: ReadonlyMap<string, number>,
+  left: (platform: string) => boolean,
+): readonly PlanWorker[] {
+  const of = new Map<string, PlanWorker[]>()
+  for (const w of workers) {
+    if (w.platform === undefined) continue
+    const all = of.get(w.platform)
+    if (all === undefined) of.set(w.platform, [w])
+    else all.push(w)
+  }
+  let kept: Set<PlanWorker> | undefined
+  for (const [platform, all] of of) {
+    // A busy one is not let go; one starting, cancelled, frees its start.
+    if (all.some((w) => !w.idle && w.starting !== true)) continue
+    const idle = all.find((w) => w.idle && w.starting !== true)
+    if (idle === undefined) continue
+    const own = sizes.filter((s) => s.platform === platform)
+    if (own.length === 0 || own.some((s) => (started.get(s.name) ?? 0) < s.max)) continue
+    if (!left(platform)) continue
+    ;(kept ??= new Set()).add(idle)
+  }
+  return kept === undefined
+    ? workers
+    : workers.map((w) => (kept!.has(w) ? { ...w, idle: false } : w))
+}
+
 /**
  * The tasks a plan counts as missed: those handed over to run, the
  * misses core's probe found, and of the commit's forecast (`likely`) only
@@ -319,6 +371,8 @@ interface Slot extends Bin {
   free?: number
   /** When its last task given in the play ends. */
   last?: number
+  /** The tasks given it in the play. */
+  given?: string[]
 }
 
 /**
@@ -350,6 +404,7 @@ function play(
   first: Map<string, number>
   ends: Map<string | undefined, number>
   free: () => Map<string, number>
+  given: () => Map<string, readonly string[]>
 } {
   // A dependency running now ends when it does; one ended or a hit, now.
   const runningIds = new Set<string>()
@@ -366,8 +421,9 @@ function play(
     memory: w.memory,
     platform: w.platform,
     at: w.at,
-    used: { cores: 0, memory: 0 },
+    used: { cores: [...(w.serving?.values() ?? [])].reduce((a, b) => a + b, 0), memory: 0 },
     running: 0,
+    serving: new Set(w.serving?.keys()),
   }))
   // Ends to come: [at, slot, cores, memory, task or undefined].
   const ends = new Ends()
@@ -479,6 +535,7 @@ function play(
       readyCount--
       count(t, -1)
       best.first ??= now
+      ;(best.given ??= []).push(id)
       best.free = Math.max(best.free ?? 0, now + (t.ms ?? UNKNOWN_MS))
       const end = now + (t.ms ?? UNKNOWN_MS)
       ends.push(
@@ -497,8 +554,10 @@ function play(
       new Map(slots.flatMap((s) => (s.first === undefined ? [] : [[s.id, s.first] as const])))
     const free = (): Map<string, number> =>
       new Map(slots.flatMap((s) => (s.free === undefined ? [] : [[s.id, s.free] as const])))
+    const given = (): Map<string, readonly string[]> =>
+      new Map(slots.flatMap((s) => (s.given === undefined ? [] : [[s.id, s.given] as const])))
     if (left === 0 && readyCount === 0)
-      return { end: last, first: first(), ends: byPlatform(), free }
+      return { end: last, first: first(), ends: byPlatform(), free, given }
     // The next moment anything changes: a task ends or a worker joins.
     let next = ends.next()
     for (const s of slots) if (s.at > now) next = Math.min(next, s.at)
@@ -512,18 +571,24 @@ function play(
         cores.set(undefined, (cores.get(undefined) ?? 0) + s.cores)
         if (s.platform !== undefined) cores.set(s.platform, (cores.get(s.platform) ?? 0) + s.cores)
       }
-      for (const e of ends.all())
-        work.set(undefined, (work.get(undefined) ?? 0) + e.cores * (e.at - now))
+      // A running task's rest on its own platform too: counted on all
+      // alone, a Mac fewer read the Linux end later (2026-11-07).
+      for (const e of ends.all()) {
+        const w = e.cores * (e.at - now)
+        work.set(undefined, (work.get(undefined) ?? 0) + w)
+        const p = e.s.platform
+        if (p !== undefined) work.set(p, (work.get(p) ?? 0) + w)
+      }
       let end = last
       for (const [p, w] of work) end = Math.max(end, now + w / Math.max(cores.get(p) ?? 0, 1e-9))
       for (const t of ready.live()) end = Math.max(end, now + tailOf(t.id))
       for (const e of ends.all())
         for (const d of (e.place >= 0 ? afterAt(e.place) : after.get(e.id!)) ?? [])
           end = Math.max(end, e.at + tailAt(d))
-      return { end, cut: true, first: first(), ends: byPlatform(), free }
+      return { end, cut: true, first: first(), ends: byPlatform(), free, given }
     }
     if (next === Infinity)
-      return { end: left === 0 ? last : Infinity, first: first(), ends: byPlatform(), free }
+      return { end: left === 0 ? last : Infinity, first: first(), ends: byPlatform(), free, given }
     now = next
     while (ends.next() <= now) {
       const { s, cores, memory, place, id } = ends.pop()
@@ -782,6 +847,55 @@ function chainMs(tasks: readonly PlanTask[], workers: readonly PlanWorker[]): nu
 const twins = (a: PlanWorker, b: PlanWorker): boolean =>
   a.cores === b.cores && a.memory === b.memory && a.platform === b.platform && a.at === b.at
 
+type Played = ReturnType<typeof play>
+
+/**
+ * `kept` less each of `added` (its last ones, in the order the run would
+ * start them) the run ends as soon without, tried last first. Sizes come in
+ * turns, so a prefix holds ones it ends as soon without: a second Mac the
+ * plan needed came after a second Linux worker it did not, and main e118ccf
+ * cancelled that one unjoined (2026-10-24). Dropped when the end moves no
+ * later and its platform's moves no further than the margin, or still ends
+ * two warm-ups before the run: room for runners the CI queues. To the run's
+ * end alone, a 110 s guess of an unmeasured chain cut every other platform
+ * to it; to its platform's alone, 4 Macs started for work 2 ended 40 s
+ * before the Linux work (main a1950a2, 2026-11-07: "we optimize for total
+ * wall time"). The live plan and the footer's advice both trim by it.
+ */
+function dropSpare(
+  added: readonly PlanWorker[],
+  kept: readonly PlanWorker[],
+  before: Played,
+  run: (ws: readonly PlanWorker[]) => Played,
+): { kept: PlanWorker[]; before: Played } {
+  let out = [...kept]
+  for (let i = added.length - 1, dropped = false; i >= 0; i--) {
+    const w = added[i]!
+    // Its twin after it stayed, and nothing moved since: without this
+    // one the play is that one's again, so it stays too. Each was a
+    // play of the whole run (2026-11-05).
+    if (i < added.length - 1 && !dropped && twins(w, added[i + 1]!)) continue
+    const without = out.filter((k) => k !== w)
+    // Given no task in a whole play, the play without it is the same.
+    if (!before.first.has(w.id) && before.cut !== true) {
+      out = without
+      dropped = true
+      continue
+    }
+    const after = run(without)
+    const ends = after.ends.get(w.platform) ?? 0
+    dropped =
+      after.end <= before.end &&
+      (ends <= (before.ends.get(w.platform) ?? 0) + MARGIN_MS ||
+        ends <= before.end - Math.max(MARGIN_MS, 2 * w.at))
+    if (dropped) {
+      out = without
+      before = after
+    }
+  }
+  return { kept: out, before }
+}
+
 /** A worker of `s` that joins `at`. */
 function fresh(
   s: { cpu: number; memory: number; platform?: string | undefined; size?: string | undefined },
@@ -875,36 +989,9 @@ export function plan(
   }
   const n = lo
   let kept = [...workers, ...added.slice(0, n)]
-  // Sizes come in turns, so the prefix can hold one the plan ends as soon
-  // without: a second Mac the plan needed came after a second Linux worker
-  // it did not, and main e118ccf cancelled that one unjoined (2026-10-24).
-  // Dropped only when neither the end nor its platform's moves past the
-  // margin: to the run's end alone, a 110 s guess of an unmeasured chain
-  // cut every other platform to it.
+  // The ones the run ends as soon without go (`dropSpare`).
   let before = best < Infinity && n > 0 ? playOf(n) : undefined
-  if (before !== undefined)
-    for (let i = n - 1, dropped = false; i >= 0; i--) {
-      // Its twin after it stayed, and nothing moved since: without this
-      // one the play is that one's again, so it stays too. Each was a
-      // play of the whole run (2026-11-05).
-      if (i < n - 1 && !dropped && twins(added[i]!, added[i + 1]!)) continue
-      const platform = added[i]!.platform
-      const without = kept.filter((k) => k !== added[i])
-      // Given no task in a whole play, the play without it is the same.
-      if (unused(before, added[i]!.id)) {
-        kept = without
-        dropped = true
-        continue
-      }
-      const after = run(without)
-      dropped =
-        after.end <= before.end &&
-        (after.ends.get(platform) ?? 0) <= (before.ends.get(platform) ?? 0) + MARGIN_MS
-      if (dropped) {
-        kept = without
-        before = after
-      }
-    }
+  if (before !== undefined) ({ kept, before } = dropSpare(added.slice(0, n), kept, before, run))
   const release: string[] = []
   // Played with the rest: left out, the next idle one and the plan's end
   // counted on a worker the run lets go.
@@ -977,11 +1064,12 @@ export function plan(
       }
     }
   }
-  const { end, first, free, cut } = run([...kept, ...standIns])
+  const { end, first, free, cut, given } = run([...kept, ...standIns])
   const start: Size[] = []
   const frees = free()
-  const started: { freeInMs: number; joinInMs: number }[] = []
-  const later: { size: Size; inMs: number; freeInMs: number; joinInMs: number }[] = []
+  const gave = given()
+  const started: Ahead['started'][number][] = []
+  const later: Ahead['later'][number][] = []
   let againInMs: number | undefined
   for (let i = 0; i < n; i++) {
     const id = added[i]!.id
@@ -993,11 +1081,17 @@ export function plan(
     // same plan 100,000 times at one instant (tests/sim.test.ts).
     if (at < warmUp + MARGIN_MS + 1) {
       start.push(candidates[i]!)
-      started.push({ freeInMs: frees.get(id)!, joinInMs: warmUp })
+      started.push({ freeInMs: frees.get(id)!, joinInMs: warmUp, given: gave.get(id)! })
     } else {
       const inMs = at - warmUp - MARGIN_MS
       againInMs = Math.min(againInMs ?? Infinity, inMs)
-      later.push({ size: candidates[i]!, inMs, freeInMs: frees.get(id)!, joinInMs: warmUp })
+      later.push({
+        size: candidates[i]!,
+        inMs,
+        freeInMs: frees.get(id)!,
+        joinInMs: warmUp,
+        given: gave.get(id)!,
+      })
     }
   }
   later.sort((a, b) => a.inMs - b.inMs)
@@ -1011,6 +1105,7 @@ export function plan(
     againInMs: untilInMs === undefined ? againInMs : Math.min(againInMs ?? Infinity, untilInMs),
     untilInMs,
     freeInMs: frees,
+    given: gave,
     later,
     started,
   }
@@ -1090,8 +1185,8 @@ export function decide(input: {
   readonly known?: ReadonlySet<string>
   /** How it orders, places and scales (`need` books already). */
   readonly how?: Strategy
-  /** The platform a task naming none runs on (`homeOf`). */
-  readonly home?: string | undefined
+  /** The platform a task naming none runs on (`homeOf`), or where each task runs (several worker types). */
+  readonly home?: Home | undefined
   /**
    * Sizes with a worker asked and not joined past its warm-up: the CI
    * queued it, and one asked now queues behind it. None of them starts.
@@ -1152,7 +1247,7 @@ export function decide(input: {
     return { ...backlog(tasks, input.workers, sizes, input.warmUpMs, how), tasks }
   const step = had === undefined ? undefined : follow(had, tasks, input, sizes, now)
   if (step !== undefined && step !== 'full') return shown(input.last!, had!, step, now, tasks)
-  const { freeInMs, later, started, untilInMs, ...p } = plan(
+  const { freeInMs, given, later, started, untilInMs, ...p } = plan(
     tasks,
     input.workers,
     sizes,
@@ -1163,7 +1258,13 @@ export function decide(input: {
     how,
   )
   if (input.last !== undefined)
-    input.last.forecast = forecastOf(p, { freeInMs, later, started, untilInMs }, tasks, input, now)
+    input.last.forecast = forecastOf(
+      p,
+      { freeInMs, given, later, started, untilInMs },
+      tasks,
+      input,
+      now,
+    )
   return { ...p, tasks }
 }
 
@@ -1186,16 +1287,23 @@ export interface Forecast {
   readonly count: number
   /** When each worker's last planned task ends, on the run's clock. */
   readonly free: ReadonlyMap<string, number>
+  /** The tasks planned on each worker. */
+  readonly given: ReadonlyMap<string, readonly string[]>
   /** When each worker still starting joins, on the run's clock. */
   readonly join: ReadonlyMap<string, number>
   /** Those of each worker started and not seen yet, in the order started. */
-  readonly fresh: readonly { readonly free: number; readonly join: number }[]
+  readonly fresh: readonly {
+    readonly free: number
+    readonly join: number
+    readonly given: readonly string[]
+  }[]
   /** Starts the plan wants later, each when due, on the run's clock. */
   readonly later: readonly {
     readonly size: Size
     readonly at: number
     readonly free: number
     readonly join: number
+    readonly given: readonly string[]
   }[]
   /** Work it saw that has since been seen running: work that left otherwise moves the plan. */
   readonly seen: Set<string>
@@ -1280,12 +1388,18 @@ function forecastOf(
     join: new Map(
       input.workers.flatMap((w) => (w.starting === true ? [[w.id, now + w.at] as const] : [])),
     ),
-    fresh: ahead.started.map((a) => ({ free: now + a.freeInMs, join: now + a.joinInMs })),
+    given: ahead.given,
+    fresh: ahead.started.map((a) => ({
+      free: now + a.freeInMs,
+      join: now + a.joinInMs,
+      given: a.given,
+    })),
     later: ahead.later.map((l) => ({
       size: l.size,
       at: now + l.inMs,
       free: now + l.freeInMs,
       join: now + l.inMs + l.joinInMs,
+      given: l.given,
     })),
     seen: new Set(),
     ends: new Map(
@@ -1429,6 +1543,7 @@ function follow(
   }
   const workers = new Set(f.workers)
   const free = new Map(f.free)
+  const given = new Map(f.given)
   const join = new Map(f.join)
   const fresh = [...f.fresh]
   const release: string[] = []
@@ -1439,6 +1554,7 @@ function follow(
       if (next === undefined) return undefined
       workers.add(w.id)
       free.set(w.id, next.free)
+      given.set(w.id, next.given)
       join.set(w.id, next.join)
     }
     // Joined sooner or later than played, past the margin.
@@ -1459,6 +1575,11 @@ function follow(
       // and one let go still counts against its size's max. A Mac let go
       // so left a Mac task no worker, and the run never ended (#4989).
       if (f.until < Infinity) return undefined
+      // A task planned on it not started: its last one ended and the next
+      // not handed to it yet. Let go, that one had no worker and the run
+      // never ended (a two-task chain on a max-1 size, its rest within the
+      // slack). Played again, the plan sees what waits for it.
+      if (given.get(w.id)?.some((id) => !f.seen.has(id)) === true) return undefined
       release.push(w.id)
       workers.delete(w.id)
     }
@@ -1466,7 +1587,7 @@ function follow(
   const start: Size[] = []
   const later = [...f.later]
   while (later.length > 0 && now >= later[0]!.at) {
-    const { size, free: ends, join: joins } = later.shift()!
+    const { size, free: ends, join: joins, given: runs } = later.shift()!
     // Its size taken up since: the plan no longer fits the run. Read
     // from what the run started, not from every task: each start read
     // them all (2026-11-05).
@@ -1481,13 +1602,14 @@ function follow(
         return undefined
     } else if (!sizes.some((s) => s.name === size.name)) return undefined
     start.push(size)
-    fresh.push({ free: ends, join: joins })
+    fresh.push({ free: ends, join: joins, given: runs })
   }
   const next: Forecast = {
     ...f,
     workers,
     count: f.count + start.length - release.length,
     free,
+    given,
     join,
     fresh,
     later,
@@ -2052,8 +2174,14 @@ export function advise(
       if (simulate(tasks, all.slice(0, mid), how) <= bound) hi = mid
       else lo = mid + 1
     }
-    const kept = all.slice(0, lo)
-    return { fleets: { fleet: fleetOf(kept, of), endMs: simulate(tasks, kept, how) }, kept }
+    // Then each the run ends as soon without, as the live plan trims.
+    const { kept, before } = dropSpare(
+      all.slice(0, lo),
+      all.slice(0, lo),
+      play(tasks, all.slice(0, lo), how),
+      (ws) => play(tasks, ws, how),
+    )
+    return { fleets: { fleet: fleetOf(kept, of), endMs: before.end }, kept }
   }
   const declared = sizes.length === 0 ? undefined : halved(sizes)?.fleets
   const lifted = sizes.map((s) => ({ ...s, max: Math.max(s.max, capOf(s.cpu, s.platform)) }))