@vzn/vx-dte 0.0.651 → 0.0.652

package/README.md

@@ -525,6 +525,8 @@ use your own instead.
   or of files a formatter changed) is sent in parts, none of it dropped.
   An order too long for one frame (a task with thousands of deps) sends
   its deps ahead of it the same way.
+- A worker gets each dependency in full once. Later orders name it, so a
+  deep graph's orders stay small.
 - A task runs with the orchestrator's environment under the worker's
   root. `HOME`, `TMPDIR`, `USER` and the like are the worker's own, unless
   the task's `env.define` sets them; `npm_execpath` is the workspace's
@@ -582,6 +584,11 @@ use your own instead.
   another. A task two such workers were sent fails, naming both; one whose
   send failed does not count. With no worker of the run left
   to take it and none starting, it fails at once.
+- A task that failed and retries (its `retries`, or the one retry a
+  known-flaky task gets) runs on another worker than the attempt that
+  failed, as core asks (`ExecuteRequest.attempt`): the worker, or what
+  ran beside it, may be the flake. With no other worker of its platform
+  in the run, it runs there again rather than wait.
 - A relay that answers nothing for 10 s, every try counted, fails every task not done
   (`the relay is unreachable`); none runs here, which may be far smaller
   than the workers. What finished is saved, so a rerun resumes from it.
@@ -746,6 +753,9 @@ machine together, and the share of their history the run's tasks used:
             probe    at 0.4s: 5 tasks left to run, 5 known misses
             asked    1 at 0.5s for 5 tasks (5 measured), plan 12.0s
             ideal    10.8s: each task as long as it took, placed perfectly
+            best     2 × small (4c/14G): 11.4s, the fewest of its sizes
+            more     3 × small (4c/14G): 10.8s, past its sizes' max
+            any      1 × (8c/28G): 10.9s, of any cores, the least core time
             total    cpu utilization 58%
 ```
 
@@ -776,6 +786,17 @@ real warm-up. That ideal end (`TaskExecutor.idealMs`) sits beside the
 real time in the run summary and the footer's `ideal` line, and
 `@vzn/vx-ci` prints it.
 
+The same replay says which workers to declare next time
+(`TaskExecutor.advice`), each from an empty run with the plan's own
+rules (the fewest that end it within its margin of the soonest): `best`
+is how many of each size; `more`, shown only when more than a size's
+`max` would end the run sooner past that margin, is how many it would
+take; `any` is one shape for each platform, of 2 to 64 cores (memory a
+core as the platform's sizes have most), the one ending as soon for the
+least core time. Raise a size's `max`, or change its `cpu` and
+`memory`, by them. They are in the footer and the run summary, and
+`@vzn/vx-ci` prints them under "Workers to declare".
+
 ## Environment
 
 What `@vzn/vx-dte` reads from the CI job it runs in:
@@ -817,16 +838,26 @@ process.env.CF_ACCESS_CLIENT_ID, … }`); an unset value is left out, and
     absent, planned as this machine's and not checked on join). With no adapter, the sizes' platforms are
     the ones joining workers may have. Only work counts:
     a task that missed the cache, or waits on a cached one that did, and
-    every uncached task, which runs every time; groups and hits need no worker. At each miss, finish and join the run plays
+    every uncached task, which runs every time; groups and hits need no worker. The run plays
     that work out on its workers and on N more (`src/planner.ts`), each new
     one joining after its size's warm-up: this run's first of that size,
     else an earlier run's, else any size's this run, else 20 s,
     and takes the fewest N that end within 5% (5 s at least) of the best.
+    It plays only two warm-ups and the longest task ahead; past that, the
+    rest ends no sooner than its longest chain, nor than its work spread
+    on the cores it has, and the next plan, a warm-up on, sees further.
     Sizes of different platforms come in turns, so of those N it drops
     each the plan ends as soon without, its platform's work no more than
     5 s later.
     That margin is spent once: later plans keep its deadline until new
     work is known. A task waiting on one that runs waits until it ends.
+    Then the run follows that plan: a start it wants later is asked when
+    due, and a worker idle with its planned work done goes. It plays again
+    only when reality leaves the plan: new work, work that leaves without
+    running, a worker that joins, leaves or warms up off plan, a task past
+    its time or ending sooner, one of no known time ending, a task starting
+    with its time, CPU or memory more than 5% off (1 s, 0.05 cores, 64 MiB
+    at least), or its window moving on.
     What is left, running tasks too, takes as many times its history as
     the run's finished tasks took theirs (once they had 20 s of it; never
     less): a task past its forecast would otherwise be planned to end now,
@@ -876,7 +907,7 @@ HEAD^`), and every task after one (`src/forecast.ts`): a lockfile or
   - `adapter` is the `DteAdapter` that starts workers, of the sizes in
     `workers`: at least one with `max` above 0, or `dte()` is refused.
     Absent, the run starts none and uses the workers that join `relay`.
-  - `relay` is the relay's URL, http(s); absent, the adapter's own.
+  - `relay` is the relay's base URL, http(s), without `/v1`, `?query` or `#fragment`; absent, the adapter's own.
   - `token` answers the relay's bearer token (default `VX_DTE_TOKEN`). It
     is asked again a minute before the token's `exp`, when it has one.
   - `unmeasured`, `{ cpu, memory }` (default 2 cores, `'4GB'`), is what a

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vzn/vx-dte",
-  "version": "0.0.651",
+  "version": "0.0.652",
   "license": "MIT",
   "description": "Distributed task execution for vx: one run spread over workers your own CI spawns, joined through a relay.",
   "keywords": [
@@ -29,10 +29,10 @@
     "bun": ">=1.4.4"
   },
   "dependencies": {
-    "@vzn/vx-dte-server": "0.0.651"
+    "@vzn/vx-dte-server": "0.0.652"
   },
   "peerDependencies": {
-    "@vzn/vx": "^0.0.651"
+    "@vzn/vx": "^0.0.652"
   },
   "repository": {
     "type": "git",