@vzn/vx-dte 0.0.651 → 0.0.652

package/src/plugin.ts

@@ -20,7 +20,7 @@ import type { Need } from './dispatch.js'
 import { booked, DEFAULT_STRATEGY, STRATEGIES, type Strategy } from './strategy.js'
 import type { Orchestrator } from './orchestrator.js'
 import type { Proof } from './seal.js'
-import type { Size } from './planner.js'
+import type { Forecast, Size } from './planner.js'
 
 /** One kind of worker the adapter can start. */
 export interface WorkerSize {
@@ -246,6 +246,12 @@ export function dte(options: DteOptions = {}) {
       `dte() option "relay" must be an http(s) URL, got ${JSON.stringify(shown(options.relay))}`,
     )
   }
+  const unrouted = options.relay === undefined ? undefined : unroutable(options.relay)
+  if (unrouted !== undefined) {
+    throw new UserError(
+      `dte() option "relay" ${unrouted}, got ${JSON.stringify(shown(options.relay!))}`,
+    )
+  }
   // On GitHub Actions with none given, one for the relay's URL.
   const token = async (relay: string): Promise<string | undefined> =>
     (await options.token?.()) ??
@@ -388,6 +394,9 @@ export function dte(options: DteOptions = {}) {
           }
           if (!/^https?:\/\//.test(relay))
             throw new UserError(`vx dte worker: VX_DTE_RELAY must be http(s), got ${shown(relay)}`)
+          const unroutedEnv = unroutable(relay)
+          if (unroutedEnv !== undefined)
+            throw new UserError(`vx dte worker: VX_DTE_RELAY ${unroutedEnv}, got ${shown(relay)}`)
           const secret = givenSecret()
           if (secret === undefined && !onGitHub()) {
             throw new UserError(
@@ -625,6 +634,8 @@ export function dte(options: DteOptions = {}) {
       // The run's deadline (`Plan.boundMs`), and the work its plans knew.
       let deadline: number | undefined
       const known = new Set<string>()
+      // The last plan, which stands while what it saw holds (`decide`).
+      const last: { forecast?: Forecast } = {}
       // A plan that needs a worker later plans again then.
       let again: ReturnType<typeof setTimeout> | undefined
       // The fewest workers that end the run's known work within a margin of
@@ -667,6 +678,8 @@ export function dte(options: DteOptions = {}) {
           how,
           home,
           queued: o.queued(warmUp),
+          last,
+          now: performance.now(),
         })
         deadline = performance.now() + p.boundMs
         for (const t of p.tasks) known.add(t.id)
@@ -787,6 +800,8 @@ export function dte(options: DteOptions = {}) {
       }
       if (needsIn === undefined) scheduled = forecast
       else forecast()
+      // Core asks the footer and the summary after teardown: the last run's graph.
+      const depsOf = (id: string): readonly string[] => (nodes ?? ran)?.get(id)?.deps ?? []
       return {
         name: 'dte',
         remote: true,
@@ -818,9 +833,14 @@ export function dte(options: DteOptions = {}) {
           replan()
           return o.execute(req)
         },
-        footer: () => o.footer(() => o.idealMs((id) => (nodes ?? ran)?.get(id)?.deps ?? [], sizes)),
+        footer: () =>
+          o.footer(
+            () => o.idealMs(depsOf, sizes),
+            () => o.advice(depsOf, sizes),
+          ),
         machines: () => o.machines(),
-        idealMs: () => o.idealMs((id) => (nodes ?? ran)?.get(id)?.deps ?? [], sizes),
+        idealMs: () => o.idealMs(depsOf, sizes),
+        advice: () => o.advice(depsOf, sizes),
         profile: () => o.profile(),
         running: (id) => o.where(id),
         demand(remaining, misses) {
@@ -1022,6 +1042,16 @@ export function homeOf(sizes: readonly Size[], host: string): string | undefined
   return of.has(host) && of.size > 1 ? host : undefined
 }
 
+/**
+ * Why a relay url no route can be appended to is refused: past a `?` or
+ * `#` every socket asked the relay's root, and one naming /v1 asked /v1/v1/….
+ */
+function unroutable(url: string): string | undefined {
+  if (/[?#]/.test(url)) return 'takes no ?query or #fragment: each route is appended to it'
+  if (/\/v1\/*$/.test(url)) return "is the relay's base, without /v1"
+  return undefined
+}
+
 /** A relay URL as a refusal may print it: a `user:pass@` would reach the CI log. */
 function shown(url: string): string {
   return url.replace(/^([a-z][a-z0-9+.-]*:\/\/)[^/?#]*@/i, '$1***@')

package/src/wire.ts

@@ -51,6 +51,11 @@ const LOST_BEATS = 3
  * orchestrator's ack answers it: one late frame is not a loss.
  */
 const QUIET_BEATS = LOST_BEATS / 2
+/**
+ * How long the orchestrator gives its own reaction to a frame (a pump, a
+ * batch) to carry the frame's ack, before the ack goes alone.
+ */
+const REACT_MS = 20
 /** A send unacknowledged as long goes again: its ack comes within it. */
 const RESEND_BEATS = LOST_BEATS / 2
 /** Why a worker ends on its orchestrator's silence. */
@@ -267,22 +272,45 @@ export async function join(
   /**
    * The orchestrator sends only orders and acks: an ack no order carried
    * goes on its own after half a heartbeat, every peer's in one frame. A
-   * worker's ride its next send, which it makes within a heartbeat.
+   * worker's ride its next send, which it makes within a heartbeat. A peer
+   * the orchestrator said nothing to in a heartbeat (a quiet worker's
+   * report) is answered once the orchestrator reacted: an order sent in
+   * reply carries the ack, and with none it goes alone, `REACT_MS` on.
    */
   let acking: ReturnType<typeof setTimeout> | undefined
+  let answering: ReturnType<typeof setTimeout> | undefined
+  const soon = new Set<string>()
+  const ack = (peer: string): void => {
+    const upTo = taken.get(peer)?.upTo
+    owing.delete(peer)
+    said.set(peer, performance.now())
+    // quiet: a lost ack only costs a resend, which is dropped as seen
+    if (upTo !== undefined) put(peer, { acked: upTo } satisfies Acked).catch(() => undefined)
+  }
   const flushAcks = (): void => {
     acking = undefined
     if (left || ended !== undefined) return
-    for (const peer of [...owing]) {
-      const upTo = taken.get(peer)?.upTo
-      owing.delete(peer)
-      // quiet: a lost ack only costs a resend, which is dropped as seen
-      if (upTo !== undefined) put(peer, { acked: upTo } satisfies Acked).catch(() => undefined)
-    }
+    for (const peer of [...owing]) ack(peer)
+  }
+  const answer = (): void => {
+    answering = undefined
+    const peers = [...soon]
+    soon.clear()
+    if (left || ended !== undefined) return
+    for (const peer of peers) if (owing.has(peer)) ack(peer)
   }
   const owe = (peer: string): void => {
     owing.add(peer)
-    if (role !== 'orchestrator' || acking !== undefined) return
+    if (role !== 'orchestrator') return
+    if (performance.now() - (said.get(peer) ?? 0) >= heartbeatMs) {
+      soon.add(peer)
+      if (answering === undefined) {
+        answering = setTimeout(answer, REACT_MS)
+        answering.unref()
+      }
+      return
+    }
+    if (acking !== undefined) return
     acking = setTimeout(flushAcks, heartbeatMs / 2)
     acking.unref()
   }

package/src/worker.ts

@@ -36,6 +36,7 @@ import {
   HOST_ENV,
   PART_LISTS,
   type DepOrder,
+  type WiredDep,
   type Load,
   type WorkerInfo,
   type RunOrder,
@@ -114,7 +115,9 @@ export async function runWorker(opts: {
   const artifacts = opts.artifacts(() => facts)
   const running = new Map<string, AbortController>()
   /** Each order's deps sent ahead of its batch, until the batch comes. */
-  const ahead = new Map<string, DepOrder[]>()
+  const ahead = new Map<string, WiredDep[]>()
+  /** Each dependency sent whole, by its task: an order after names it alone (`WiredDep`). */
+  const known = new Map<string, DepOrder>()
   const work = new Set<Promise<void>>()
   let root = opts.root
   let realRoot = opts.root
@@ -440,6 +443,8 @@ export async function runWorker(opts: {
                 ? undefined
                 : new Set(m.sandbox.keyed.map((k) => path.join(opts.root, k))),
               m.nested.map((n) => path.join(opts.root, n)),
+              undefined,
+              (m.sandbox.reads ?? []).map((r) => path.join(opts.root, r)),
             )
       const output = new BoundedCapture()
       const req: ExecuteRequest = {
@@ -621,11 +626,28 @@ export async function runWorker(opts: {
             else await floor.rearm(m.sandboxes)
           }
           for (const t of m.tasks) {
+            const sent = ahead.get(t.task)
+            ahead.delete(t.task)
+            // Learned in the order sent, a task run already too: the run counts them sent.
+            let missing: string | undefined
+            const deps = (sent === undefined ? t.deps : [...sent, ...t.deps]).map((d): DepOrder => {
+              if (typeof d !== 'string') {
+                known.set(d.task, d)
+                return d
+              }
+              const got = known.get(d)
+              if (got === undefined) missing ??= d
+              return got!
+            })
             // One it runs already is not run twice.
             if (running.has(t.task)) continue
-            const deps = ahead.get(t.task)
-            ahead.delete(t.task)
-            start(deps === undefined ? t : { ...t, deps: [...deps, ...t.deps] })
+            if (missing !== undefined) {
+              const reason = `was sent ${missing} by name, never whole`
+              ui.print('err', ui.status('error', t.task, `could not run: ${reason}`))
+              await say({ type: 'fault', task: t.task, reason }).catch(unsent('fault'))
+              continue
+            }
+            start({ ...t, deps })
           }
         }
       }