@vzn/vx-dte 0.0.651 → 0.0.653

package/src/dispatch.ts

@@ -16,15 +16,133 @@ export function ordered(
   cores: number,
 ): string[] {
   if (how === 'fifo') return [...ids]
-  const byTail = (x: string, y: string): number => tail(y) - tail(x)
-  if (how === 'critical-path') return [...ids].sort(byTail)
+  // Each one's key read once: a comparator that read the tails read them
+  // q log q times at each event, most of a 10 000-task sim (2026-11-05).
+  const tails = ids.map(tail)
+  if (how === 'critical-path') return byKey(ids, tails)
   // Troublesome: within a quarter of the longest chain, or half a worker wide.
   let longest = 0
-  for (const id of ids) longest = Math.max(longest, tail(id))
-  const hard = (id: string): boolean => tail(id) >= 0.75 * longest || need(id).cores >= cores / 2
-  return [...ids].sort((x, y) => Number(hard(y)) - Number(hard(x)) || byTail(x, y))
+  for (const t of tails) longest = Math.max(longest, t)
+  // Hard ones first: a key above every tail.
+  const keys = ids.map((id, i) =>
+    tails[i]! >= 0.75 * longest || need(id).cores >= cores / 2
+      ? tails[i]! + longest + 1
+      : tails[i]!,
+  )
+  return byKey(ids, keys)
+}
+
+/**
+ * `ids` by `keys`, highest first, ties in the order they came. The queue
+ * comes back as it left plus what got ready since: the run of it already
+ * in order is merged with the rest, sorted, and not sorted again.
+ */
+function byKey(ids: readonly string[], keys: readonly number[]): string[] {
+  let run = 1
+  while (run < ids.length && keys[run]! <= keys[run - 1]!) run++
+  if (run >= ids.length) return [...ids]
+  const rest: number[] = []
+  for (let i = run; i < ids.length; i++) rest.push(i)
+  rest.sort((x, y) => keys[y]! - keys[x]! || x - y)
+  const out: string[] = []
+  let i = 0
+  let j = 0
+  while (i < run && j < rest.length)
+    out.push(keys[i]! >= keys[rest[j]!]! ? ids[i++]! : ids[rest[j++]!]!)
+  while (i < run) out.push(ids[i++]!)
+  while (j < rest.length) out.push(ids[rest[j++]!]!)
+  return out
+}
+
+/** How `dispatch` sees the waiting tasks and the run. */
+export interface Dispatching {
+  readonly how: Strategy
+  /** Each one's longest chain after it (`tailsMs`); none: they go in the order they came. */
+  readonly tail?: ((id: string) => number) | undefined
+  /** What it asks, as history said. */
+  readonly need: (id: string) => Need
+  /** What it books now (`Orchestrator.booking`); default `need`'s. */
+  readonly book?: (need: Need) => Need
+  /** Its direct dependencies (`Ask.up`). */
+  readonly deps: (id: string) => readonly string[] | undefined
+  /** Whether it may go now, and where (`Orchestrator.pin`): `'wait'` not yet, `'done'` it ended. */
+  readonly gate?: (id: string) => 'wait' | 'done' | { only?: string; avoid?: string }
+  /** A worker bigger than `above` of `platform` is coming (`assign`'s `waits`). */
+  readonly waits?: (above: NonNullable<Need['above']>, platform: string | undefined) => boolean
+}
+
+/**
+ * Where the `waiting` tasks go now: ordered (`ordered`), gated, and placed
+ * (`assign`). The one rule of the live run and of the sims, which keep
+ * their waiting tasks in a `Queue` placing as this does: each kept its
+ * own, and the sims passed while runs placed otherwise (2026-11-05).
+ * `left`: the ones that stay waiting, in order.
+ */
+export function dispatch<B extends Bin>(
+  waiting: readonly string[],
+  bins: readonly B[],
+  o: Dispatching,
+): { to: Map<string, B>; left: string[] } {
+  const queue =
+    o.tail === undefined
+      ? waiting
+      : ordered(
+          waiting,
+          o.how.order,
+          o.tail,
+          o.need,
+          bins.reduce((n, b) => Math.max(n, b.cores), 1),
+        )
+  // The least any ask needs: once no worker takes it, the pass ends. Each
+  // pump read every queued task, 8000 of them a pump (2026-10-25).
+  const floor = { cores: Infinity, memory: Infinity }
+  const needs: Need[] = []
+  for (const id of queue) {
+    const need = o.book === undefined ? o.need(id) : o.book(o.need(id))
+    needs.push(need)
+    floor.cores = Math.min(floor.cores, need.cores)
+    floor.memory = Math.min(floor.memory, need.memory)
+  }
+  // Asks are made as the pass reads them: it ends at the first no worker
+  // takes, and making every queued one's at each event was most of a
+  // 5000-task sim (2026-11-05).
+  const read: string[] = []
+  // The bins' bounds as assign keeps them: an ask no bin can take or hold
+  // for is not made. Each such ask read every bin, and a full run's queue
+  // of them at each event was most of a 10 000-task sim (2026-11-05).
+  const bounds: Bounds = { done: false, open: true, free: 0, cores: 0, memory: 0 }
+  let i = 0
+  function* asks(): Generator<Ask> {
+    for (; i < queue.length; i++) {
+      const id = queue[i]!
+      if (bounds.done) return
+      if (dead(needs[i]!, bounds)) {
+        read.push(id)
+        continue
+      }
+      const gate = o.gate?.(id) ?? {}
+      if (gate === 'done') continue
+      read.push(id)
+      if (gate === 'wait') continue
+      yield { id, need: needs[i]!, up: o.deps(id) ?? [], ...gate }
+    }
+  }
+  const to = assign(asks(), bins, o.waits, o.how.place, { floor, kinds: Infinity, bounds })
+  const left = read.filter((id) => !to.has(id))
+  // The pass ended at the ask it read last, and took or left it.
+  for (let j = i < queue.length && read.at(-1) === queue[i] ? i + 1 : i; j < queue.length; j++)
+    left.push(queue[j]!)
+  return { to, left }
 }
 
+/**
+ * The most workers a task is scored on, of those it fits, as Kubernetes
+ * scores a share of its nodes: scoring every one cost the orchestrator
+ * 15% more CPU at 200 workers, and the sims ended within 0.4% sampling
+ * even 2 (2026-11-05).
+ */
+const SAMPLE = 16
+
 /** What a task asks of a worker: its history's cores and peak memory. */
 export interface Need {
   readonly cores: number
@@ -39,6 +157,12 @@ export interface Need {
    * free core, but a run of only such tasks still asks enough workers.
    */
   readonly ask?: { readonly cores: number; readonly memory: number } | undefined
+  /**
+   * Its persistent dependencies' bases, cores (`server-fit.ts`): a worker
+   * not running one yet books its base once beside the task, and keeps it
+   * booked while it serves.
+   */
+  readonly servers?: readonly { readonly id: string; readonly cores: number }[] | undefined
 }
 
 /** A worker as dispatch sees it: its size and what is in use on it now. */
@@ -54,13 +178,19 @@ export interface Bin {
   readonly has?: ReadonlySet<string>
   /** Its machine's platform (`linux-x64`), as it reported or its size declares. */
   readonly platform?: string | undefined
+  /** The servers it runs, each base booked: a task needing one books no base here. */
+  readonly serving?: Set<string>
 }
 
 export interface Ask {
   readonly id: string
   readonly need: Need
-  /** Its dependencies, all the way up: a worker holding them is preferred. */
-  readonly up?: Iterable<string>
+  /**
+   * Its direct dependencies: a worker holding most is preferred. One holds
+   * what was sent with each, so the direct ones say enough: counting every
+   * upstream for every worker read thousands an ask (2026-11-05).
+   */
+  readonly up?: readonly string[]
   /** Names its need: asks of one kind fit and fail alike (`kindOf`). */
   readonly kind?: string
   /** The one bin that may take it: it holds files no cache does. */
@@ -71,7 +201,14 @@ export interface Ask {
 
 /** What `Ask.kind` names: every field of a need `assign` reads. */
 export function kindOf(need: Need): string {
-  return `${need.cores}\0${need.memory}\0${need.above?.cores}\0${need.above?.memory}\0${need.platform}`
+  return `${need.cores}\0${need.memory}\0${need.above?.cores}\0${need.above?.memory}\0${need.platform}\0${need.servers?.map((s) => s.id).join('\0')}`
+}
+
+/** The cores `need` books on `bin`: its own, and the base of each server `bin` does not run yet. */
+function coresOn(bin: Bin, need: Need): number {
+  let cores = need.cores
+  for (const s of need.servers ?? []) if (bin.serving?.has(s.id) !== true) cores += s.cores
+  return cores
 }
 
 /**
@@ -82,9 +219,10 @@ export function kindOf(need: Need): string {
 export function fits(bin: Bin, need: Need): boolean {
   if (need.platform !== undefined && bin.platform !== need.platform) return false
   if (bin.running === 0) return true
+  const cores = coresOn(bin, need)
   return (
-    need.cores < bin.cores &&
-    bin.used.cores + need.cores <= bin.cores + 1e-9 &&
+    cores < bin.cores &&
+    bin.used.cores + cores <= bin.cores + 1e-9 &&
     bin.used.memory + need.memory <= bin.memory
   )
 }
@@ -130,7 +268,12 @@ export function assign<B extends Bin>(
   for (const ask of asks) {
     if (
       all !== undefined &&
-      (spent.size >= all.kinds || !bins.some((b) => !held.has(b) && fits(b, all.floor)))
+      (spent.size >= all.kinds ||
+        // Its bounds, kept as it gives, say it: a read of every bin an ask
+        // was most of a plan's play (2026-11-05).
+        (bounds !== undefined
+          ? bounds.done
+          : !bins.some((b) => !held.has(b) && fits(b, all.floor))))
     )
       break
     if (ask.kind !== undefined && spent.has(ask.kind)) continue
@@ -143,20 +286,24 @@ export function assign<B extends Bin>(
         : bins.filter((b) => (ask.only === undefined || b.id === ask.only) && b.id !== ask.avoid)
     const of =
       need.platform === undefined ? allowed : allowed.filter((b) => b.platform === need.platform)
-    const anyBigger = of.some(bigger)
+    // With no size to beat, every bin is bigger: no copy of them an ask.
+    const anyBigger = need.above === undefined ? of.length > 0 : of.some(bigger)
     if (!anyBigger && need.above !== undefined && waits(need.above, need.platform)) {
       if (ask.kind !== undefined) spent.add(ask.kind)
       continue
     }
-    const pool = anyBigger ? of.filter(bigger) : of
-    const up = ask.up === undefined ? [] : [...ask.up]
+    const pool = anyBigger && need.above !== undefined ? of.filter(bigger) : of
     let best: B | undefined
     let bestScore: [number, number] = [0, 0]
-    for (const b of pool) {
+    let seen = 0
+    for (let i = 0; i < pool.length; i++) {
+      const b = pool[i]!
       if (held.has(b) || !fits(b, need)) continue
+      // Workers fill in order, so the first that fit hold the fullest.
+      if (++seen > SAMPLE) break
       let has = 0
-      for (const id of up) if (b.has?.has(id) === true) has++
-      const score: [number, number] = [has, fit(b, need, place, pool.indexOf(b))]
+      for (const id of ask.up ?? []) if (b.has?.has(id) === true) has++
+      const score: [number, number] = [has, fit(b, need, place, i)]
       if (
         best === undefined ||
         score[0] > bestScore[0] ||
@@ -182,7 +329,8 @@ export function assign<B extends Bin>(
     }
     spent.clear()
     out.set(ask.id, best)
-    best.used.cores += Math.min(need.cores, best.cores)
+    best.used.cores += Math.min(coresOn(best, need), best.cores)
+    for (const sv of need.servers ?? []) best.serving?.add(sv.id)
     best.used.memory += Math.min(need.memory, best.memory)
     best.running++
     rebound()
@@ -207,6 +355,16 @@ export interface Bounds {
   cores: number
   /** The least memory free on one. */
   memory: number
+  /** The same of each platform's own: a task naming one fits only those. */
+  of?: Map<string, Room>
+}
+
+/** What `Bounds` says of a set of bins. */
+interface Room {
+  open: boolean
+  free: number
+  cores: number
+  memory: number
 }
 
 function boundsOf(
@@ -220,30 +378,41 @@ function boundsOf(
   out.free = -Infinity
   out.cores = Infinity
   out.memory = Infinity
+  out.of?.clear()
   for (const b of bins) {
     if (held.has(b)) continue
     if (floor !== undefined && fits(b, floor)) out.done = false
-    if (b.running === 0) out.open = true
-    out.free = Math.max(out.free, b.cores - b.used.cores)
-    out.cores = Math.min(out.cores, b.cores)
-    out.memory = Math.min(out.memory, b.memory - b.used.memory)
+    room(out, b)
+    if (b.platform === undefined) continue
+    out.of ??= new Map()
+    let p = out.of.get(b.platform)
+    if (p === undefined)
+      out.of.set(
+        b.platform,
+        (p = { open: false, free: -Infinity, cores: Infinity, memory: Infinity }),
+      )
+    room(p, b)
   }
 }
 
+function room(r: Room, b: Bin): void {
+  if (b.running === 0) r.open = true
+  r.free = Math.max(r.free, b.cores - b.used.cores)
+  r.cores = Math.min(r.cores, b.cores)
+  r.memory = Math.min(r.memory, b.memory - b.used.memory)
+}
+
 /**
  * True when `assign` would fit `need` on no bin and hold none for it, by
  * `fits` and its hold rule: no bin is empty, and on each it is less than
  * the bin, fits its memory, and wants more cores than are free.
  */
 export function dead(need: Need, b: Bounds): boolean {
-  return (
-    need.platform === undefined &&
-    need.above === undefined &&
-    !b.open &&
-    need.cores > b.free + 1e-9 &&
-    need.cores < b.cores &&
-    need.memory <= b.memory
-  )
+  if (need.above !== undefined) return false
+  // Of its platform's bins: with none free of a hold, no ask of it does a thing.
+  const r = need.platform === undefined ? b : b.of?.get(need.platform)
+  if (r === undefined) return true
+  return !r.open && need.cores > r.free + 1e-9 && need.cores < r.cores && need.memory <= r.memory
 }
 
 /** How well `need` suits `b` by `place`: the higher, the better. */
@@ -266,3 +435,344 @@ function fit(b: Bin, need: Need, place: Strategy['place'], index: number): numbe
     }
   }
 }
+
+/**
+ * The live run's waiting tasks, kept across its passes in the order
+ * `ordered` gives (`critical-path`, `fifo`) and grouped by platform and
+ * cores' class: a pass places exactly as `dispatch` over the whole list,
+ * but passes a group whole while no worker has room for any of it, where
+ * each pass ordered and read every waiting task, a fifth of a 10 000-task
+ * sim (2026-11-06). `graphene` ranks by the longest waiting tail, which
+ * moves as tasks leave: it keeps the list and `dispatch`.
+ */
+export class Queue {
+  private list: string[] | undefined
+  private readonly groups = new Map<string, Group>()
+  private readonly of = new Map<string, Entry>()
+  private front = 0
+  private back = 0
+
+  constructor(
+    private readonly how: Strategy,
+    private readonly tail: ((id: string) => number) | undefined,
+    private readonly need: (id: string) => Need,
+  ) {
+    if (how.order === 'graphene' && tail !== undefined) this.list = []
+  }
+
+  get size(): number {
+    return this.list?.length ?? this.of.size
+  }
+
+  has(id: string): boolean {
+    return this.list?.includes(id) ?? this.of.has(id)
+  }
+
+  /** In the order a pass reads them. */
+  ids(): string[] {
+    if (this.list !== undefined) return [...this.list]
+    return [...this.of.values()].sort((a, b) => (before(a, b) ? -1 : 1)).map((e) => e.id)
+  }
+
+  /** `ids` join, in order, behind every one ranked as high, or `front` before all. */
+  add(ids: readonly string[], front = false): void {
+    if (this.list !== undefined) {
+      if (front) this.list.unshift(...ids)
+      else this.list.push(...ids)
+      return
+    }
+    if (front) this.front -= ids.length
+    let seq = front ? this.front : this.back
+    for (const id of ids) {
+      const need = this.need(id)
+      const e: Entry = {
+        id,
+        rank: this.how.order === 'fifo' || this.tail === undefined ? 0 : -this.tail(id),
+        seq: seq++,
+        need,
+        group: undefined!,
+      }
+      const odd = need.above !== undefined || need.ask !== undefined || need.cores === Infinity
+      const key = `${need.platform}\0${odd ? 'odd' : Math.floor(Math.log2(Math.max(need.cores, 1e-6)) * CLASSES)}`
+      let g = this.groups.get(key)
+      if (g === undefined) this.groups.set(key, (g = new Group(odd, need.platform)))
+      e.group = g
+      g.add(e)
+      this.of.set(id, e)
+    }
+    if (!front) this.back = seq
+  }
+
+  /**
+   * History changed (`tail`, `need`): the waiting rank and group by it,
+   * ties in the order they stood. A rank is read once, as a task joins:
+   * on CI the roots join before the default branch's timings land, each
+   * at an unknown task's 30 s, and every test shard ready later ranked
+   * above them, so `test.wire` (73 s) waited 129 s for a worker (main
+   * 1c91c9d, 2026-11-07). `graphene` reads ranks at each pass.
+   */
+  rerank(): void {
+    if (this.list !== undefined) return
+    const ids = this.ids()
+    this.groups.clear()
+    this.of.clear()
+    this.front = 0
+    this.back = 0
+    this.add(ids)
+  }
+
+  delete(id: string): boolean {
+    if (this.list !== undefined) {
+      const at = this.list.indexOf(id)
+      if (at >= 0) this.list.splice(at, 1)
+      return at >= 0
+    }
+    const e = this.of.get(id)
+    if (e === undefined) return false
+    this.drop(e)
+    return true
+  }
+
+  private drop(e: Entry): void {
+    this.of.delete(e.id)
+    e.gone = true
+    if (e.group.drop() === 0)
+      for (const [k, g] of this.groups) if (g === e.group) this.groups.delete(k)
+  }
+
+  /**
+   * Where the waiting tasks go now, as `dispatch` places them; the ones
+   * placed or found done leave. `book`, if given, must keep a need's
+   * order by cores among needs alike but for cores.
+   */
+  pass<B extends Bin>(
+    bins: readonly B[],
+    o: Omit<Dispatching, 'how' | 'tail' | 'need'>,
+  ): Map<string, B> {
+    if (this.list !== undefined) {
+      const { to, left } = dispatch(this.list, bins, {
+        ...o,
+        how: this.how,
+        tail: this.tail,
+        need: this.need,
+      })
+      this.list = left
+      return to
+    }
+    return this.place(bins, o)
+  }
+
+  private place<B extends Bin>(
+    bins: readonly B[],
+    o: Omit<Dispatching, 'how' | 'tail' | 'need'>,
+  ): Map<string, B> {
+    const book = o.book ?? ((n: Need): Need => n)
+    const gs = [...this.groups.values()]
+    const floor = { cores: Infinity, memory: Infinity }
+    for (const g of gs) {
+      g.at = g.head()
+      const low = g.low()
+      if (low === undefined) continue
+      // Booked as its least: what each of its tasks books is at least this.
+      g.lo = g.odd ? Infinity : book(low).cores
+      floor.cores = Math.min(floor.cores, g.odd ? g.oddFloor(book) : g.lo)
+      floor.memory = Math.min(floor.memory, g.memory())
+    }
+    const bounds: Bounds = { done: false, open: true, free: 0, cores: 0, memory: 0 }
+    const done: Entry[] = []
+    let cursor: Entry | undefined
+    function* asks(): Generator<Ask> {
+      for (;;) {
+        if (bounds.done) return
+        // The group whose next is first, past any no worker has room for now.
+        let g: Group | undefined
+        let second: Entry | undefined
+        for (const x of gs) {
+          if (x.at >= x.q.length) continue
+          if (!x.odd && x.full(bounds)) continue
+          if (cursor !== undefined && !before(cursor, x.q[x.at]!)) x.at = x.after(cursor)
+          x.at = x.skip(x.at)
+          const e = x.q[x.at]
+          if (e === undefined) continue
+          if (g === undefined || before(e, g.q[g.at]!)) {
+            if (g !== undefined && (second === undefined || before(g.q[g.at]!, second)))
+              second = g.q[g.at]!
+            g = x
+          } else if (second === undefined || before(e, second)) second = e
+        }
+        if (g === undefined) return
+        // Its run up to the next group's first, read one by one as before.
+        for (;;) {
+          const e = g.q[g.at]
+          if (e === undefined || (second !== undefined && !before(e, second))) break
+          g.at = g.skip(g.at + 1)
+          cursor = e
+          if (bounds.done) return
+          const need = book(e.need)
+          if (dead(need, bounds)) continue
+          const gate = o.gate?.(e.id) ?? {}
+          if (gate === 'done') {
+            done.push(e)
+            continue
+          }
+          if (gate === 'wait') continue
+          yield { id: e.id, need, up: o.deps(e.id) ?? [], ...gate }
+          break
+        }
+      }
+    }
+    const to = assign(asks(), bins, o.waits, this.how.place, { floor, kinds: Infinity, bounds })
+    for (const e of done) if (!e.gone) this.drop(e)
+    for (const id of to.keys()) this.drop(this.of.get(id)!)
+    return to
+  }
+}
+
+/** Classes a doubling of cores spans (`Queue`'s groups). */
+const CLASSES = 4
+
+interface Entry {
+  readonly id: string
+  /** The lower first, then the lower `seq`. */
+  readonly rank: number
+  readonly seq: number
+  readonly need: Need
+  group: Group
+  gone?: boolean
+}
+
+function before(a: Entry, b: Entry): boolean {
+  return a.rank < b.rank || (a.rank === b.rank && a.seq < b.seq)
+}
+
+/** Waiting tasks of one platform and cores' class, in rank order; gone ones linger until half are. */
+class Group {
+  q: Entry[] = []
+  private gone = 0
+  /** Where a pass reads next. */
+  at = 0
+  /** The least any of it books, this pass. */
+  lo = Infinity
+  /** The most cores and memory one asked: kept as they joined until it is read again without the gone. */
+  private hiCores = -Infinity
+  private hiMemory = -Infinity
+  /** Its least cores and memory, gone ones lazily left off the top. */
+  private readonly byCores: Entry[] = []
+  private readonly byMemory: Entry[] = []
+
+  constructor(
+    readonly odd: boolean,
+    readonly platform: string | undefined,
+  ) {}
+
+  add(e: Entry): void {
+    let lo = 0
+    let hi = this.q.length
+    // Most join last: a search from the end.
+    if (hi === 0 || before(this.q[hi - 1]!, e)) lo = hi
+    while (lo < hi) {
+      const mid = (lo + hi) >> 1
+      if (before(this.q[mid]!, e)) lo = mid + 1
+      else hi = mid
+    }
+    this.q.splice(lo, 0, e)
+    this.hiCores = Math.max(this.hiCores, e.need.cores)
+    this.hiMemory = Math.max(this.hiMemory, e.need.memory)
+    push(this.byCores, e, (x) => x.need.cores)
+    push(this.byMemory, e, (x) => x.need.memory)
+  }
+
+  /** One of it left: how many are left. */
+  drop(): number {
+    this.gone++
+    const left = this.q.length - this.gone
+    if (this.gone > left) {
+      this.q = this.q.filter((e) => !e.gone)
+      this.gone = 0
+      this.hiCores = -Infinity
+      this.hiMemory = -Infinity
+      for (const e of this.q) {
+        this.hiCores = Math.max(this.hiCores, e.need.cores)
+        this.hiMemory = Math.max(this.hiMemory, e.need.memory)
+      }
+    }
+    return left
+  }
+
+  head(): number {
+    return this.skip(0)
+  }
+
+  skip(p: number): number {
+    while (p < this.q.length && this.q[p]!.gone === true) p++
+    return p
+  }
+
+  /** The first place ranked past `cursor`. */
+  after(cursor: Entry): number {
+    let p = this.at
+    let hi = this.q.length
+    while (p < hi) {
+      const mid = (p + hi) >> 1
+      if (!before(cursor, this.q[mid]!)) p = mid + 1
+      else hi = mid
+    }
+    return p
+  }
+
+  low(): Need | undefined {
+    return top(this.byCores, (x) => x.need.cores)?.need
+  }
+
+  memory(): number {
+    return top(this.byMemory, (x) => x.need.memory)?.need.memory ?? Infinity
+  }
+
+  /** An odd group's least booked: read one by one, as books of each differ. */
+  oddFloor(book: (n: Need) => Need): number {
+    let least = Infinity
+    for (let p = this.at; p < this.q.length; p++)
+      if (this.q[p]!.gone !== true) least = Math.min(least, book(this.q[p]!.need).cores)
+    return least
+  }
+
+  /** No worker of its platform has room for any of it now, as `dead` says of each. */
+  full(b: Bounds): boolean {
+    const r = this.platform === undefined ? b : b.of?.get(this.platform)
+    if (r === undefined) return true
+    return !r.open && this.lo > r.free + 1e-9 && this.hiCores < r.cores && this.hiMemory <= r.memory
+  }
+}
+
+/** A binary min-heap of entries by `by`. */
+function push(h: Entry[], e: Entry, by: (e: Entry) => number): void {
+  h.push(e)
+  let i = h.length - 1
+  while (i > 0) {
+    const p = (i - 1) >> 1
+    if (by(h[p]!) <= by(h[i]!)) break
+    ;[h[p], h[i]] = [h[i]!, h[p]!]
+    i = p
+  }
+}
+
+/** The least of `h` not gone, the gone ones above it popped. */
+function top(h: Entry[], by: (e: Entry) => number): Entry | undefined {
+  while (h.length > 0 && h[0]!.gone === true) {
+    const last = h.pop()!
+    if (h.length === 0) break
+    h[0] = last
+    let i = 0
+    for (;;) {
+      const l = 2 * i + 1
+      const r = l + 1
+      let m = i
+      if (l < h.length && by(h[l]!) < by(h[m]!)) m = l
+      if (r < h.length && by(h[r]!) < by(h[m]!)) m = r
+      if (m === i) break
+      ;[h[m], h[i]] = [h[i]!, h[m]!]
+      i = m
+    }
+  }
+  return h[0]
+}

package/src/forecast.ts

@@ -62,7 +62,6 @@ export function likelyMisses(
     return c
   }
   for (const [id, n] of nodes)
-    if (n.config.exec?.command !== undefined && n.config.cache !== undefined && changes(id))
-      out.add(id)
+    if (n.config.exec?.command !== undefined && n.config.cache === true && changes(id)) out.add(id)
   return out
 }

package/src/github.ts

@@ -14,8 +14,6 @@ import { printable } from './printable.js'
 export interface GithubOptions {
   /** The workers' workflow file in `.github/workflows` (default `vx-worker.yml`). */
   readonly workflow?: string
-  /** The runner label of each size, by size name, which `vx dte init` writes; absent, its platform's GitHub-hosted runner. */
-  readonly runsOn?: Readonly<Record<string, string>>
   /**
    * Variables the run hands its workers, as the workflow's `env` input (a
    * JSON object): a value the run's job decides, such as a server's URL
@@ -33,7 +31,6 @@ interface Job {
 
 const KEYS: PluginOptionKinds<GithubOptions> = {
   workflow: 'string',
-  runsOn: 'object',
   env: 'object',
 }