@meshbench/client 0.0.1

package/lib/errors.mjs

@@ -0,0 +1,150 @@
+// What went wrong, in a shape a script can catch.
+//
+// The workbench answers with a sentence and a code. The sentence is the good
+// part - "no node is running firmware, so there is nothing to send to" - and it
+// survives untouched; the code decides which class it becomes, because
+// `instanceof` is what JavaScript has where Go has errors.Is and Python has an
+// exception hierarchy. A caller that matched on prose would break the day the
+// workbench reworded a refusal.
+
+import { PROTOCOL, RELEASE } from "./pairing.mjs";
+
+/** Anything this client throws. */
+export class MeshbenchError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "MeshbenchError";
+  }
+}
+
+/** A verb the workbench declined, with its own words kept.
+ *
+ *  Named for the workbench rather than for the refusal because that is what a
+ *  Node script has caught since the first release, and the name is the API. */
+export class WorkbenchError extends MeshbenchError {
+  /** Carries the code beside the message rather than folding it into the
+   *  prose, because a caller that has to match on prose breaks the day the
+   *  workbench rewords a refusal. */
+  constructor(verb, message, code) {
+    super(verb ? `${verb}: ${message}` : message);
+    this.name = "WorkbenchError";
+    /** Which verb was refused, so a log line says what was asked as well as
+     *  what came back. Empty for a refusal that answered no verb - the
+     *  connection itself being turned away. */
+    this.verb = verb || "";
+    /** The workbench's own words, unaltered and without the verb in front. */
+    this.detail = message;
+    /** How the refusal was classified, so a caller can branch on it instead of
+     *  on prose: the workbench's own code (`not_found`, `conflict`, `closing`
+     *  and the rest the control socket defines) when a verb was refused, and
+     *  `protocol_mismatch` or `version_mismatch` when this client was the end
+     *  that refused, at the handshake - the same two the workbench uses, so a
+     *  script branching on the code need not care which end noticed. Empty when
+     *  a refusal arrived without one, so test it rather than assume it is set. */
+    this.code = code || "";
+  }
+}
+
+/** Not a method this build has.
+ *
+ *  Nearly always a client older or newer than the workbench, which connecting
+ *  is supposed to have caught first, so seeing this is worth looking into. */
+export class UnknownVerb extends WorkbenchError {}
+
+/** The verb refused what it was given. */
+export class BadParams extends WorkbenchError {}
+
+/** No node, build, area or job of that name. */
+export class NotFound extends WorkbenchError {}
+
+/** The right request in the wrong state: nothing loaded, nothing running to
+ *  send to, no import preview to commit. */
+export class Conflict extends WorkbenchError {}
+
+/** A request this session cannot serve at all - a window verb with no window,
+ *  or hardware that is not here. */
+export class Unavailable extends WorkbenchError {}
+
+/** The workbench is shutting down. Retry against a new session rather than
+ *  report a bug. */
+export class Closing extends WorkbenchError {}
+
+const BY_CODE = {
+  unknown_verb: UnknownVerb,
+  bad_params: BadParams,
+  not_found: NotFound,
+  conflict: Conflict,
+  unavailable: Unavailable,
+  closing: Closing,
+};
+
+/** The right class for a code.
+ *
+ *  An unrecognised code becomes a plain WorkbenchError rather than an error
+ *  about the error: a workbench newer than this client may classify something
+ *  in a way this version has never heard of, and swallowing that would be worse
+ *  than passing it on. */
+export function refusal(verb, message, code) {
+  const Cls = BY_CODE[code] || WorkbenchError;
+  const e = new Cls(verb, message, code);
+  e.name = Cls.name;
+  return e;
+}
+
+/** A client and a workbench that cannot speak to each other's frames.
+ *
+ *  Its own class rather than a WorkbenchError carrying a code, because a
+ *  script has to be able to tell "these two cannot talk" from "this build
+ *  declined what I asked" with `instanceof`, and the two remedies have nothing
+ *  in common. */
+export class ProtocolMismatch extends WorkbenchError {
+  constructor(message, { client = PROTOCOL, workbench = 0 } = {}) {
+    super("", message, "protocol_mismatch");
+    this.name = "ProtocolMismatch";
+    /** The wire version each end speaks. `workbench` is 0 when the workbench
+     *  refused the connection before it would say what it was. */
+    this.client = client;
+    this.workbench = workbench;
+  }
+}
+
+/** A released client driving a workbench from a different release.
+ *
+ *  Separate from ProtocolMismatch: two ends can understand each other's frames
+ *  perfectly and still be a pair nobody ever built or tested together. */
+export class VersionMismatch extends WorkbenchError {
+  constructor(message, { client = RELEASE, workbench = "" } = {}) {
+    super("", message, "version_mismatch");
+    this.name = "VersionMismatch";
+    /** The release each end belongs to. `workbench` is empty when the
+     *  workbench refused before it would say what it was. */
+    this.client = client;
+    this.workbench = workbench;
+  }
+}
+
+/** A wait that ran out, saying what it wanted and what it last saw.
+ *
+ *  Not a bare deadline: "timeout" in a CI log tells whoever reads it nothing,
+ *  and the state at the moment it gave up is the only thing that does. */
+export class Timeout extends MeshbenchError {
+  constructor(what, afterMs, last = "") {
+    super(`waited ${Math.round(afterMs / 1000)}s for ${what}` +
+      (last ? `; last saw: ${last}` : ""));
+    this.name = "Timeout";
+    this.what = what;
+    this.afterMs = afterMs;
+    this.last = last;
+  }
+}
+
+/** The workbench's refusal of what this client declared, as the mismatch it is
+ *  rather than as whichever call happened to be in flight failing - which is
+ *  the confusion the declaration exists to end. Everything else is left alone. */
+export function asMismatch(e) {
+  if (e instanceof ProtocolMismatch || e instanceof VersionMismatch) return e;
+  if (!(e instanceof WorkbenchError)) return e;
+  if (e.code === "protocol_mismatch") return new ProtocolMismatch(e.detail);
+  if (e.code === "version_mismatch") return new VersionMismatch(e.detail);
+  return e;
+}

package/lib/firmware.mjs

@@ -0,0 +1,249 @@
+// What this machine can run, and what it is running.
+
+import { NotFound, refusal } from "./errors.mjs";
+import { FIRMWARE_WAIT_MS, JOB_WAIT_MS, waitFor } from "./wait.mjs";
+import { describeBuild } from "./values.mjs";
+
+/** Which build a call means, from either a library row or a bare label.
+ *
+ *  A row carries all three names and they are sent together, so the call cannot
+ *  land on a different build that happens to share a label. A bare label sends
+ *  only what was given, and the workbench refuses it when it is ambiguous
+ *  rather than guessing - acting on the wrong build is a rename of somebody
+ *  else's image. */
+function buildID(build, { board = "", role = "" } = {}) {
+  if (build && typeof build === "object") {
+    return { version: build.version, role: build.role, board: build.board };
+  }
+  const p = { version: build };
+  if (role) p.role = role;
+  if (board) p.board = board;
+  return p;
+}
+
+/** What this machine can run, and what it is running. Live. */
+export class Firmware {
+  constructor(wb) { this._wb = wb; }
+
+  /** Every build, published or on disk, with what runs it - the rows, not a
+   *  count of them. */
+  async library() {
+    return ((await this._wb.call("firmware.library")) || {}).builds || [];
+  }
+
+  /** Only the ones this machine holds, which is the only thing that decides
+   *  what a node can run. A build that failed to download and one in daily use
+   *  look identical from anywhere else. */
+  async onDisk() {
+    return (await this.library()).filter((b) => b.on_disk);
+  }
+
+  /** One build by version, and by board where the version alone is ambiguous -
+   *  which it is for every board image, because "wadamesh" is not a build until
+   *  it is wadamesh for a particular piece of hardware. */
+  async find(version, board = "") {
+    for (const b of await this.library()) {
+      if (b.version === version && (!board || b.board === board)) return b;
+    }
+    throw new NotFound("firmware.library",
+      `no build "${version}" for board "${board}"`, "not_found");
+  }
+
+  /** Everything known about one build: where it is, what it is, and what has
+   *  been decided about it. */
+  async details(build, opts) {
+    return (await this._wb.call("firmware.details", buildID(build, opts))) || {};
+  }
+
+  /** Rename a build, move it to another board or role, or change how it is run,
+   *  and report it as it now stands.
+   *
+   *  Renaming moves the file, because the name is the identity: a board image
+   *  is stored as `<board>/<role>@<label>.bin` and nothing else records what it
+   *  is. Nodes pinned to the old name are repointed, or they would fail at
+   *  their next start with "no image in the cache" about a build sitting in the
+   *  library under its new name.
+   *
+   *  Every setting left out is left alone, which is why they are undefined
+   *  rather than "" or false: "leave this" and "turn it off" are different
+   *  answers. */
+  async update(build, {
+    board = "", role = "", label, newRole, newBoard,
+    coprocAtReset, cardRequired, notes,
+  } = {}) {
+    const p = buildID(build, { board, role });
+    if (label !== undefined) p.label = label;
+    if (newRole !== undefined) p.new_role = newRole;
+    if (newBoard !== undefined) p.new_board = newBoard;
+    if (coprocAtReset !== undefined) p.coproc_at_reset = coprocAtReset;
+    if (cardRequired !== undefined) p.card_required = cardRequired;
+    if (notes !== undefined) p.notes = notes;
+    const moved = (await this._wb.call("firmware.update", p)) || {};
+    // Read back under whatever it is called now, which is not what it was
+    // called if this was a rename.
+    return this.details(moved.version || "",
+      { board: moved.board || "", role: moved.role || "" });
+  }
+
+  /** Open the build's own window - what a click on a library row does. Refused
+   *  by a workbench with no interface. */
+  async window(build, opts) {
+    await this._wb.call("firmware.window", buildID(build, opts));
+  }
+
+  /** Ask the catalogue what is published, which is how a build nobody has
+   *  downloaded becomes offerable. */
+  async scan() { await this._wb.call("firmware.rescan"); }
+
+  /** Fetch a published build. It returns once the download has been asked for,
+   *  not once it has landed: wait on the job.
+   *
+   *  `role` is a plain string here and a Role everywhere else, deliberately:
+   *  this one names a published release asset, and the catalogue's own
+   *  spellings are not always the application names the verbs are keyed on. */
+  async download(role, version, board = "") {
+    const p = { role, version };
+    if (board) p.board = board;
+    await this._wb.call("firmware.download", p);
+  }
+
+  /** Take a build from a path - the one way a locally built image gets into the
+   *  library.
+   *
+   *  `label` is what the library will know it by and what a node pins. Left out
+   *  it is a timestamp, so importing twice gives two builds rather than one
+   *  that quietly replaced the other - which matters the moment you want to put
+   *  the new one on a node and delete the old. */
+  async import(path, role, { board = "", label = "" } = {}) {
+    const p = { path, role };
+    if (board) p.board = board;
+    if (label) p.label = label;
+    return (await this._wb.call("firmware.import", p)) || {};
+  }
+
+  /** Remove a build from the cache, and say what was removed.
+   *
+   *  By path, and the workbench refuses any path outside the firmware cache. A
+   *  build nodes are still pinned to will go: they keep the pin, which then
+   *  cannot be honoured and fails at start - so move them onto the replacement
+   *  first. */
+  async delete(build) {
+    if (!build || !build.path) {
+      throw refusal("firmware.delete",
+        `${describeBuild(build)} has no path on this machine to delete`,
+        "bad_params");
+    }
+    const got = await this._wb.call("firmware.delete", { path: build.path });
+    return (got || {}).deleted || "";
+  }
+
+  /** Compile a MeshCore checkout and put the results in the library.
+   *
+   *  Both roles unless one is named, deliberately. A locally built repeater
+   *  compiled against a stale shim once answered console output with 0x06 where
+   *  the host expects 0x07: it connected, misbehaved and exited. Two arms of a
+   *  comparison built at different moments from different trees measure the
+   *  build process rather than the firmware, so the easy thing here is the
+   *  thing that builds them together.
+   *
+   *  Blocks until it is done - a MeshCore build is a minute or two per role -
+   *  and returns what the library now holds that was built locally. */
+  async build(checkout, { role = "", label = "", waitMs = JOB_WAIT_MS } = {}) {
+    const p = { source: checkout };
+    if (role) p.role = role;
+    if (label) p.label = label;
+    const got = (await this._wb.call("firmware.build", p)) || {};
+    await this._wb.job(got.job || "firmware-build").wait(waitMs);
+    return (await this.library()).filter((b) => b.version.startsWith("local-"));
+  }
+
+  /** Pin every role that needs one to the newest build on this machine, and
+   *  report what it chose.
+   *
+   *  What a script wants almost every time: this mesh, whatever this machine
+   *  holds, rather than a version typed into the script that goes stale. A run
+   *  refuses to start until every role is answered, so the alternative is the
+   *  same loop written out in every caller.
+   *
+   *  It refuses by name when a role has nothing, because "no companion build"
+   *  is a thing to go and fix rather than a reason to start a mesh with a
+   *  silent hole in it. */
+  async useWhatIsHere() {
+    const have = (await this.onDisk()).filter((b) => !b.board);
+    const chosen = {};
+    for (const want of await this.needed()) {
+      const pick = have.filter((b) => b.role === want.role).pop();
+      if (!pick) {
+        throw new NotFound("firmware.needed",
+          `no ${want.role} build on this machine: ` +
+          `meshbench firmware download ${want.role}`, "not_found");
+      }
+      await this.useForRole(want.role, pick);
+      chosen[want.role] = pick;
+    }
+    return chosen;
+  }
+
+  /** Pin every node of a role to one build. */
+  async useForRole(role, build) {
+    const version = typeof build === "string" ? build : build.version;
+    await this._wb.call("firmware.set", { role, version });
+  }
+
+  /** Bring up firmware on every node.
+   *
+   *  Asynchronous, and always has been: it answers with what it has begun, not
+   *  with what is up. It was synchronous once, and on 155 nodes that froze the
+   *  window and the socket together for as long as it was left - which read as
+   *  a crash and was reported as one. Wait with waitStarted. */
+  async start() { await this._wb.call("firmware.start"); }
+
+  /** How far a start has got. */
+  async state() { return (await this._wb.call("firmware.state")) || {}; }
+
+  /** The roles this scenario has nodes for and no build pinned to, with what
+   *  could be pinned. A run refuses to start until every one is answered. */
+  async needed() {
+    return ((await this._wb.call("firmware.needed")) || {}).roles || [];
+  }
+
+  /** Wait for every node's firmware to be up. `timeoutMs` is wall clock.
+   *
+   *  `nodes` here is the nodes that run firmware, which is not every node: an
+   *  SDR observer and an emitter never boot one. It used to be every node, so a
+   *  fixture holding either reported "56 of 58" until the timeout with no way
+   *  to see which two.
+   *
+   *  Which is why this names the stragglers rather than counting them. Ten
+   *  minutes of "56 of 58" tells you nothing; two node names tell you whether a
+   *  build is missing or a board is wedged. */
+  waitStarted(timeoutMs = FIRMWARE_WAIT_MS) {
+    let named = 0;
+    let last = "";
+    return waitFor(async () => {
+      const st = await this.state();
+      const running = st.running || 0;
+      const nodes = st.nodes || 0;
+      if (!st.starting && nodes > 0 && running >= nodes) return [true, ""];
+      // The names cost a /proc read per node and this polls while firmware is
+      // starting, which is the busiest moment there is - every fiftieth of a
+      // second is how a diagnostic becomes the fault it was meant to explain,
+      // and it timed the socket out. Once every ten seconds is often enough for
+      // something a person only reads when the wait fails.
+      if (Date.now() - named >= 10_000) {
+        named = Date.now();
+        last = await this._stragglers();
+      }
+      return [false, `${running} of ${nodes} running${last}`];
+    }, timeoutMs, "firmware to come up");
+  }
+
+  async _stragglers() {
+    const waiting = (await this._wb.nodeStats())
+      .filter((s) => !s.running).map((s) => s.name);
+    if (waiting.length === 0) return "";
+    let shown = waiting.slice(0, 4).join(", ");
+    if (waiting.length > 4) shown += ` and ${waiting.length - 4} more`;
+    return `; waiting on ${shown}`;
+  }
+}

package/lib/launch.mjs

@@ -0,0 +1,112 @@
+// Starting a workbench of one's own, and waiting for it to answer.
+//
+// Separate from the Workbench itself because it is process work rather than
+// protocol work: which binary, which address, and how long to wait before
+// deciding it is not coming.
+
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+import { MeshbenchError } from "./errors.mjs";
+import {
+  BINARY_ENV, Connection, MAX_UNIX_PATH, RENDEZVOUS_ENV,
+} from "./socket.mjs";
+
+/** How long to give a workbench to answer before deciding it is not coming.
+ *  A national fixture takes a while to open and a small one does not. */
+export const START_TIMEOUT_MS = 90_000;
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+/** Start `meshbench <command>` and connect to it.
+ *
+ *  Resolves to the connection, the child, and the rendezvous file the child was
+ *  told to write - which the connection had to be pointed at, because the
+ *  per-user one names whatever else on this machine last left an address. */
+export async function launch(command, {
+  fixture = "", seed = 0, socket = "", binary = "", args = [],
+  startTimeoutMs = START_TIMEOUT_MS, callTimeoutMs, stderr = "inherit",
+} = {}) {
+  const chosen = address(socket);
+  const exe = binary || process.env[BINARY_ENV] || "meshbench";
+  const argv = [command, "-control-socket", chosen.address];
+  if (fixture) argv.push("-fixture", fixture);
+  if (seed) argv.push("-seed", String(seed));
+  argv.push(...args);
+
+  const env = { ...process.env };
+  if (chosen.rendezvous) env[RENDEZVOUS_ENV] = chosen.rendezvous;
+  let child;
+  try {
+    child = spawn(exe, argv, { env, stdio: ["ignore", "inherit", stderr] });
+  } catch (e) {
+    throw new MeshbenchError(`could not start ${exe}: ${e.message}`);
+  }
+  let exited = null;
+  child.on("error", (e) => { exited = e.message; });
+  child.on("exit", (code) => { exited ??= `exited with ${code}`; });
+
+  // Wait for the socket rather than for a fixed moment: a sleep long enough for
+  // a national fixture is wasted on every run of a small one.
+  const deadline = Date.now() + startTimeoutMs;
+  for (;;) {
+    if (exited) {
+      throw new MeshbenchError(
+        `${exe} ${command} ${exited} before answering at ${chosen.address}`);
+    }
+    try {
+      const conn = await Connection.open({
+        address: chosen.address, rendezvous: chosen.rendezvous,
+        connectTimeoutMs: 1000, callTimeoutMs,
+      });
+      return { conn, child, rendezvous: chosen.rendezvous };
+    } catch (e) {
+      if (Date.now() > deadline) {
+        child.kill("SIGKILL");
+        throw new MeshbenchError(
+          `${exe} ${command} did not answer at ${chosen.address} within ` +
+          `${Math.round(startTimeoutMs / 1000)}s: ${e.message}`);
+      }
+      await sleep(50);
+    }
+  }
+}
+
+/** An address of its own unless one was named, so launching two of these does
+ *  not have them fight over the per-user default.
+ *
+ *  Two reasons that path may not do. Windows has no unix socket a Node client
+ *  can reach, and a temporary directory on macOS is long enough on its own to
+ *  exceed sun_path. Either way, loopback - with a rendezvous file of its own
+ *  too, or two sessions would overwrite each other's port and token in the
+ *  per-user one. */
+function address(named) {
+  if (named) return { address: named, rendezvous: "" };
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "meshbench"));
+  const sock = path.join(dir, "control.sock");
+  if (process.platform === "win32" || sock.length > MAX_UNIX_PATH) {
+    return { address: "tcp", rendezvous: path.join(dir, "control.json") };
+  }
+  return { address: sock, rendezvous: "" };
+}
+
+/** Stop a workbench this client started.
+ *
+ *  An interrupt asks the run to stop its firmware on the way out, which on
+ *  fifty-eight emulated nodes is not instant. Windows has no SIGINT to send a
+ *  process that is not sharing a console, so it is killed there and whatever
+ *  the run was holding is the operating system's problem. */
+export async function stop(child, graceMs = 20_000) {
+  if (child.exitCode !== null || child.signalCode !== null) return;
+  child.kill(process.platform === "win32" ? "SIGKILL" : "SIGINT");
+  const deadline = Date.now() + graceMs;
+  while (child.exitCode === null && child.signalCode === null) {
+    if (Date.now() > deadline) {
+      child.kill("SIGKILL");
+      return;
+    }
+    await sleep(50);
+  }
+}

package/lib/live.mjs

@@ -0,0 +1,103 @@
+// Bringing a real deployment in from a live feed.
+//
+// Four steps in a fixed order, and every one of them has been skipped by
+// somebody at least once. The two that get missed are the last two, and missing
+// them does not fail: the mesh comes up with regions inferred but never
+// applied, which transmits everything, relays nothing, and reports no error at
+// all. It reads as bad RF.
+//
+// So the steps are here individually, because sometimes you want to look at a
+// preview before committing - and `pull` runs all four, because the ordinary
+// case is wanting the whole deployment and the ordinary mistake is stopping
+// early.
+
+import { MeshbenchError } from "./errors.mjs";
+import { Strategy } from "./sets.mjs";
+import { ImportPreview } from "./values.mjs";
+import { JOB_WAIT_MS } from "./wait.mjs";
+
+/** How far back to read traffic when working out what each node holds.
+ *
+ *  A week, because that is what it takes for the quiet regions to say anything
+ *  at all: on ScotMesh a small region is about sixty packets in seven days, and
+ *  a shorter window drops it entirely rather than reporting it as thin. */
+export const DEFAULT_WINDOW_HOURS = 7 * 24;
+
+/** A live feed, and the deployment it describes. Live in both senses. */
+export class Live {
+  constructor(wb) { this._wb = wb; }
+
+  /** Fetch, commit, read the traffic, and apply what it implies.
+   *
+   *  The whole chain, in the order that works. `windowHours` is how far back
+   *  into the feed's history to read - the mesh's own past, not your patience;
+   *  `waitMs` is yours.
+   *
+   *  Returns what the fetch found. Link measurement is still running when this
+   *  returns on anything but a small mesh, so follow it with `wb.waitIdle()`
+   *  before starting a run. */
+  async pull(url, { strategy = Strategy.REPLACE,
+    windowHours = DEFAULT_WINDOW_HOURS, waitMs = JOB_WAIT_MS } = {}) {
+    const preview = await this.fetch(url);
+    if (preview.nodes === 0) {
+      throw new MeshbenchError(
+        `${url} described ${preview.records} nodes, none usable`);
+    }
+    await this.commit(strategy);
+    await this.infer({ windowHours, waitMs });
+    await this.applyRegions();
+    return preview;
+  }
+
+  /** Point at a feed without reading it, and say how the URL was tidied.
+   *
+   *  A method rather than a property, because a property implies something to
+   *  read back and the session offers no way to ask what its source currently
+   *  is. One that answered from a value this object happened to remember would
+   *  be right until anything else set it. */
+  async setSource(url) {
+    return ((await this._wb.call("import.set_source", { url })) || {}).url || url;
+  }
+
+  /** Read the deployment and say what would change, changing nothing. */
+  async fetch(url = "") {
+    if (url) await this.setSource(url);
+    return new ImportPreview((await this._wb.call("import.fetch")) || {});
+  }
+
+  /** Apply the fetched nodes to the scenario, and say how many it now holds.
+   *
+   *  "replace-all" is what the shipped fixtures were built with; "add" keeps
+   *  what is already here and skips names that clash.
+   *
+   *  Measuring the links afterwards is a job rather than part of this call - 676
+   *  nodes is 228,000 terrain paths over real ground - so this returns while
+   *  that is still running. */
+  async commit(strategy = Strategy.REPLACE) {
+    return ((await this._wb.call("import.commit", { strategy })) || {}).nodes || 0;
+  }
+
+  /** Read the feed's recent traffic to work out what each node holds.
+   *
+   *  This is the step that decides whether anything relays. A node whose regions
+   *  are unknown forwards nothing, and nothing says so.
+   *
+   *  `windowHours` is the feed's own past; `waitMs` is how long you will sit
+   *  here for it. A week of ScotMesh is around 150,000 packets and several
+   *  minutes of paging. */
+  async infer({ windowHours = DEFAULT_WINDOW_HOURS, waitMs = JOB_WAIT_MS } = {}) {
+    if (!(windowHours > 0)) {
+      throw new MeshbenchError("infer() needs a window, in hours of the feed's past");
+    }
+    await this._wb.call("infer.run", { hours: windowHours });
+    await this._wb.job("infer").wait(waitMs);
+  }
+
+  /** Put the inferred regions onto the nodes, and say how many took one.
+   *
+   *  The forgotten step. Everything above can succeed and the mesh still be
+   *  silent until this runs. */
+  async applyRegions() {
+    return ((await this._wb.call("infer.apply")) || {}).applied || 0;
+  }
+}