@openmixer/plugin-qualify 0.18.5 → 0.20.0

package/dist/qualify-sync.js

@@ -23,20 +23,21 @@ import { createConnection } from "node:net";
 import { homedir, tmpdir } from "node:os";
 import { basename, dirname, join, resolve, sep } from "node:path";
 import { clapQualifyTools } from "./clap-qualify.js";
-import { DISTRIBUTED_DIR_SYSTEM, EMPTY_LAYER, applyDistributed, distributedUri, hostClassOfBoard, matchDistributed, readBoardModel, readDistributedLayer } from "./distributed-records.js";
+import { DISTRIBUTED_DIR_SYSTEM, EMPTY_LAYER, applyDistributed, distributedUri, hostClassOfBoard, outcomeOfVerdict, matchDistributed, readBoardModel, readDistributedLayer } from "./distributed-records.js";
 import { clapSearchPath, parseClapScan } from "./clap-loader.js";
 import { HOSTING_CODE } from "./hosting-codes.js";
 import { shippedHostProfile } from "./host-profiles.js";
 import { lv2BundlesOnPath, manifestPlugins } from "./lv2-loader.js";
-import { judgmentPinEntries, pinsFile } from "./pins-file.js";
+import { judgmentPinEntries, pinClearLine, pinLineUri, pinsFile } from "./pins-file.js";
+import { POOL_RESULT, completePool, judgePoolRun, pinAfterPool, pinFromRecordWithPool, poolEnv, spawnedPoolRunner } from "./qualify-pool.js";
 import { hostdPinFiles } from "./hostd-pin-files.js";
 import { qualifyTargets } from "./probe-runner.js";
 import { GRID_FULL, parseGridSpec } from "./measurement-grid.js";
 import { adapterPass } from "./qualify-adapter-pass.js";
 import { ISOLATED_RESULT, baseSteps, completeIsolated, isolatedCell, missingSteps, judgeIsolatedRun, owesIsolated, pinAfterStep, spawnedIsolatedRunner } from "./qualify-isolated.js";
-import { lv2World, rejudgeState, memoryPass } from "./qualify-rejudge.js";
+import { lv2World, rejudgeRecord, rejudgeState, rejudgeToolName, memoryPass } from "./qualify-rejudge.js";
 import { memoryBoundOf, parseMemoryLimit } from "./memory-bound.js";
-import { rewriteRecord, writeQualification } from "./qualification-record.js";
+import { QUALIFICATION_RECORD_SCHEMA, latencyNeverTaken, rewriteRecord, writeQualification } from "./qualification-record.js";
 import { ADMIT_STEP_MS_ENV, DESCRIPTOR_DIR_STATE_SUBDIR, DESCRIPTOR_DIR_SYSTEM, MEMORY_PASS_PROBE_NOTES, QUALIFY_QUANTA, QUALIFY_RATES } from "./qualify-declarations.js";
 import { toolsDir } from "./tool-paths.js";
 import { writeFileWhole } from "./whole-file.js";
@@ -100,6 +101,7 @@ export function parseSyncArgs(argv) {
     let memoryOnly = false;
     let adapterOnly = false;
     let isolatedOnly = false;
+    let poolOnly = false;
     let help = false;
     for (let i = 0; i < argv.length; i++) {
         const a = argv[i];
@@ -121,6 +123,8 @@ export function parseSyncArgs(argv) {
             adapterOnly = true;
         else if (a === "--isolated-only")
             isolatedOnly = true;
+        else if (a === "--pool-only")
+            poolOnly = true;
         else if (a === "--help")
             help = true;
         else if (a === "--grid-hosts")
@@ -137,11 +141,11 @@ export function parseSyncArgs(argv) {
         else
             return { ok: false, error: `unknown argument ${a}` };
     }
-    if (rejudge && (memoryOnly || adapterOnly || isolatedOnly || force || refreshPinsOnly))
-        return { ok: false, error: "--rejudge measures nothing: it goes with none of --memory-only, --adapter-only, --force and --refresh-pins" };
-    if ([memoryOnly, adapterOnly, isolatedOnly, refreshPinsOnly].filter(Boolean).length > 1)
-        return { ok: false, error: "--memory-only, --adapter-only and --refresh-pins are different runs: one at a time" };
-    return { ok: true, args: { ...(config === undefined ? {} : { config }), system, force, noDistributed, noWait, refreshPins: refreshPinsOnly, rejudge, memoryOnly, adapterOnly, isolatedOnly, help, values } };
+    if (rejudge && (memoryOnly || adapterOnly || isolatedOnly || poolOnly || force || refreshPinsOnly))
+        return { ok: false, error: "--rejudge measures nothing: it goes with none of --memory-only, --adapter-only, --isolated-only, --pool-only, --force and --refresh-pins" };
+    if ([memoryOnly, adapterOnly, isolatedOnly, poolOnly, refreshPinsOnly].filter(Boolean).length > 1)
+        return { ok: false, error: "--memory-only, --adapter-only, --isolated-only, --pool-only and --refresh-pins are different runs: one at a time" };
+    return { ok: true, args: { ...(config === undefined ? {} : { config }), system, force, noDistributed, noWait, refreshPins: refreshPinsOnly, rejudge, memoryOnly, adapterOnly, isolatedOnly, poolOnly, help, values } };
 }
 export function syncHelpText() {
     const rows = SYNC_SETTINGS.map((s) => `  ${`${flagOf(s.key)} <value>`.padEnd(36)}${s.meaning}${s.default === "" ? "" : ` (default: ${s.default})`}`);
@@ -157,6 +161,7 @@ export function syncHelpText() {
         "  --rejudge                           derive every record's verdicts, tiers and pin again from the figures it holds; measures nothing",
         "  --memory-only                       measure only the footprint of each recorded plugin at the Pi's cells and merge it; with --force, those already merged too",
         "  --isolated-only                     run only the isolated step each record still owes, adding it to the record's run",
+        "  --pool-only                         run only the pool step each CLAP record still owes: a plugin that asks for the thread pool is run with it off and on, and its pin gets pool=cores or pool=off",
         "  --adapter-only                      run each LV2 plugin only under omx-clap-host's LV2 adapter at the Pi's cells, on private JACK servers, and merge it; with --force, those already done too",
         "  --grid-hosts                        the fast grid, the same as --grid hosts (7 cells with the shipped hosts)",
         "  --help                              this text",
@@ -448,6 +453,27 @@ export function machineReason(p) {
         return errno;
     return /wrote no document|cannot run the probe runner/.test(p.detail ?? "") ? "the measurement wrote no document" : undefined;
 }
+/**
+ * The figure the records of a recorded entry never took, or `undefined`: a record whose probe ran before that figure's
+ * pass ({@link latencyNeverTaken}) owes a measurement, and the sync measures the entry again although its bytes are the
+ * ones it recorded. A record that cannot be read owes nothing here: the sync's other checks deal with it.
+ */
+export function figureOwed(entry) {
+    for (const p of entry.plugins) {
+        if (p.record === undefined)
+            continue;
+        let r;
+        try {
+            r = JSON.parse(readFileSync(p.record, "utf8"));
+        }
+        catch {
+            continue;
+        }
+        if (r.schema === QUALIFICATION_RECORD_SCHEMA && latencyNeverTaken(r))
+            return "latency";
+    }
+    return undefined;
+}
 /** What the quick qualification never measures, stated in every record it writes. */
 export const QUICK_NOT_MEASURED = [{ dimension: "stability", code: HOSTING_CODE.stabilityUnsoaked }];
 const EMPTY_STATE = { schema: SYNC_STATE_SCHEMA, entries: {} };
@@ -599,8 +625,8 @@ const isolatedEnv = (ctx) => ({ ...ctx.env, [ADMIT_STEP_MS_ENV]: String(ctx.sett
 /** Each judged run of a pass as the plugins it qualified: the record written, the pin taken, the outcome. */
 function judgedPlugins(ctx, runs, describeProblem) {
     const host = ctx.settings.hostProfile.id;
-    const entries = runs.map(({ bytes, judgment }) => {
-        const { recordPath, record } = writeQualification(ctx.settings.qualificationDir, bytes, judgment, QUICK_NOT_MEASURED);
+    const entries = runs.map(({ bytes, judgment, stderr }) => {
+        const { recordPath, record } = writeQualification(ctx.settings.qualificationDir, bytes, judgment, QUICK_NOT_MEASURED, stderr);
         const steps = baseSteps(record, describeProblem);
         let pin = withHostdFiles(ctx, judgmentPinEntries(judgment, host)[0]);
         let { outcome, code } = outcomeOf(judgment, host);
@@ -629,6 +655,13 @@ function judgedPlugins(ctx, runs, describeProblem) {
                 code = undefined;
             }
         }
+        // the pool is for a CLAP plugin that runs: the thread pool is granted by measuring it, here and nowhere else
+        if (judgment.output.plugin.format === "clap" && pin !== undefined && pin.verdict !== "refused" && outcome === "qualified") {
+            const runner = ctx.poolRunner ?? spawnedPoolRunner();
+            const step = judgePoolRun(runner(pin.uri, isolatedCell(record, host), poolEnv(ctx.env, ctx.settings.budgetS)));
+            steps.push(step);
+            pin = pinAfterPool(pin, step);
+        }
         rewriteRecord(recordPath, { ...record, run: { id: judgment.output.run.id, steps } });
         const plugin = { uri: pin?.uri ?? judgment.output.plugin.id, outcome, ...(code === undefined ? {} : { code }), ...(pin === undefined ? {} : { pin }), record: recordPath };
         return { plugin, judgedHere: judgment.hosts.some((h) => h.verdict.host === host) };
@@ -761,7 +794,7 @@ export function qualifyItem(ctx, item, files) {
  * a step that could not run stays owed: the next pass tries it again.
  */
 export function isolatedPass(ctx, state) {
-    const count = { isolated: 0, refused: 0, notRun: 0 };
+    const count = { isolated: 0, refused: 0, notRun: 0, repinned: 0 };
     const runner = ctx.isolatedRunner ?? spawnedIsolatedRunner();
     const host = ctx.settings.hostProfile.id;
     const entries = {};
@@ -781,8 +814,19 @@ export function isolatedPass(ctx, state) {
                     return p;
                 }
                 const done = completeIsolated(path, record, p.pin?.uri ?? record.plugin.id, isolatedCell(record, host), runner, isolatedEnv(ctx));
-                if (done === undefined)
-                    return p;
+                if (done === undefined) {
+                    // a plugin the isolated step already decided but the state holds no pin for: the record keeps the bytes and the
+                    // step, and the pin follows them (hostd names the files, as at every other pin)
+                    if (p.pin !== undefined)
+                        return p;
+                    const rebuilt = withHostdFiles(ctx, pinFromRecordWithPool(record));
+                    if (rebuilt === undefined)
+                        return p;
+                    count.repinned++;
+                    ctx.log(`${p.uri}: pinned again from its record (isolated step ${rebuilt.verdict ?? "undecided"})`);
+                    const { code: _c, ...rest } = p;
+                    return rest.outcome === "qualified" && rebuilt.verdict === "refused" ? { ...rest, outcome: "refused", pin: rebuilt } : { ...rest, pin: rebuilt };
+                }
                 ctx.log(`${p.uri}: isolated step ${done.step.result}${done.step.code === undefined ? "" : ` (${done.step.code})`}`);
                 const pin = pinAfterStep(p.pin, done.step);
                 const { pin: _pin, code: _code, ...rest } = p;
@@ -798,7 +842,50 @@ export function isolatedPass(ctx, state) {
             }),
         };
     }
-    return { ...count, state: count.isolated + count.refused + count.notRun === 0 ? state : { ...state, entries } };
+    return { ...count, state: count.isolated + count.refused + count.notRun + count.repinned === 0 ? state : { ...state, entries } };
+}
+/**
+ * The pool steps the CLAP records of a state still owe, each extending its record's run. A plugin's pin takes the pool word
+ * of its step (`cores`, or `off` for a plugin that was measured and gains nothing) and none for a plugin that does not ask
+ * for the pool. A step that could not run stays owed: the next pass tries it again.
+ */
+export function poolPass(ctx, state) {
+    const count = { cores: 0, off: 0, notAsked: 0, notRun: 0 };
+    const runner = ctx.poolRunner ?? spawnedPoolRunner();
+    const host = ctx.settings.hostProfile.id;
+    const entries = {};
+    for (const [key, entry] of Object.entries(state.entries)) {
+        entries[key] = {
+            ...entry,
+            plugins: entry.plugins.map((p) => {
+                if (p.record === undefined || !p.record.endsWith(".qualification.json") || p.pin === undefined || p.pin.verdict === "refused")
+                    return p;
+                const path = join(ctx.settings.qualificationDir, basename(p.record));
+                let record;
+                try {
+                    record = JSON.parse(readFileSync(path, "utf8"));
+                }
+                catch {
+                    ctx.log(`${p.uri}: its record does not read; no pool step`);
+                    return p;
+                }
+                const done = completePool(path, record, p.pin.uri, isolatedCell(record, host), runner, poolEnv(ctx.env, ctx.settings.budgetS));
+                if (done === undefined)
+                    return p;
+                ctx.log(`${p.uri}: pool step ${done.step.result}${done.step.code === undefined ? "" : ` (${done.step.code})`}`);
+                if (done.step.result === POOL_RESULT.cores)
+                    count.cores++;
+                else if (done.step.result === POOL_RESULT.off)
+                    count.off++;
+                else if (done.step.result === POOL_RESULT.notAsked)
+                    count.notAsked++;
+                else
+                    count.notRun++;
+                return { ...p, pin: pinAfterPool(p.pin, done.step) };
+            }),
+        };
+    }
+    return { ...count, state: count.cores + count.off + count.notAsked + count.notRun === 0 ? state : { ...state, entries } };
 }
 // --- the distributed records ----------------------------------------------------------------------------------------
 /** The layer a run reads: none under `--force` or `--no-distributed`, or without a host class. */
@@ -839,10 +926,36 @@ function takeDistributed(ctx, layer, item, files) {
             ctx.log(`distributed: ${distributedUri(item, r)}: its record lacks the step${missing.length === 1 ? "" : "s"} ${missing.join(", ")}; measured here`);
             return undefined;
         }
+        if (latencyNeverTaken(r.record)) {
+            ctx.log(`distributed: ${distributedUri(item, r)}: its record never took the latency figure (a probe from before that pass); measured here`);
+            return undefined;
+        }
+    }
+    // The set was judged by the plugin-qualify that measured it. Its figures are carried across and judged again under
+    // today's rules, as an upgrade's are (`--rejudge`): a verdict of an older judge (RT-unsafe read as refused, before
+    // #196) is never taken as it stands. A record today's judge cannot decide for this host is measured here.
+    const by = rejudgeToolName();
+    const at = new Date(started).toISOString();
+    const records = [];
+    for (const r of match.records) {
+        let record;
+        try {
+            record = rejudgeRecord(r.record, readFileSync(join(r.path, "..", r.record.probe.file)), { host, by, at }).record;
+        }
+        catch (e) {
+            ctx.log(`distributed: ${distributedUri(item, r)}: ${e.message}; measured here`);
+            return undefined;
+        }
+        const v = record.verdicts.find((x) => x.host === host);
+        if (v !== undefined && outcomeOfVerdict(v) === "unmeasured") {
+            ctx.log(`distributed: ${distributedUri(item, r)}: judged again, ${v.deciding ?? "unknown"} for ${host}; measured here`);
+            return undefined;
+        }
+        records.push({ ...r, record });
     }
     let plugins;
     try {
-        plugins = applyDistributed(ctx.settings.qualificationDir, item, match, host);
+        plugins = applyDistributed(ctx.settings.qualificationDir, item, { ...match, records }, host);
     }
     catch (e) {
         ctx.log(`distributed: ${distributedUri(item, match.records[0])}: ${e.message}; measured here`);
@@ -882,7 +995,7 @@ function pinLinesOf(text) {
     const out = new Map();
     for (const line of text.split("\n"))
         if (line !== "" && !line.startsWith("#"))
-            out.set(line.split(" ")[1], line);
+            out.set(pinLineUri(line), line);
     return out;
 }
 /** The pin lines of `after` that `before` does not hold as they are. */
@@ -895,9 +1008,9 @@ export function removedPinUris(before, after) {
     const now = pinLinesOf(after);
     return [...pinLinesOf(before).keys()].filter((uri) => !now.has(uri));
 }
-/** `<id>@<version>-<binary sha first 12>`, the stem a qualification record, its probe copy and its descriptor share. */
+/** `<id>@<version>-<binary sha first 12>`, the stem a qualification record, its probe copy, its children's stderr and its descriptor share. */
 export function recordStem(recordPath) {
-    return /^(.*-[0-9a-f]{12})\.(?:[^.]+\.(?:qualification|probe)|unmeasured)\.json$/.exec(basename(recordPath))?.[1];
+    return /^(.*-[0-9a-f]{12})\.(?:(?:[^.]+\.(?:qualification|probe)|unmeasured)\.json|[^.]+\.stderr\.[0-9a-f]{12}\.log)$/.exec(basename(recordPath))?.[1];
 }
 /**
  * A stem's id and binary hash, its version segment dropped: what a record and its descriptor share even when their
@@ -1137,7 +1250,7 @@ export function pluginCountsLine(c) {
     return `plugins ${part(c.plugins)}, offered ${part(c.offered)}, not offered ${part(c.notOffered)}`;
 }
 export function summaryLine(s) {
-    return `qualified ${String(s.qualified)}, skipped ${String(s.skipped)}, refused ${String(s.refused)}, crashed ${String(s.crashed)}, hung ${String(s.hung)}, unmeasured ${String(s.unmeasured)}, distributed ${String(s.distributed)}${s.refreshed ? `, pins refreshed ${String(s.refreshed)}` : ""}${s.rejudge === undefined ? "" : `, rejudged ${String(s.rejudge.changed)}, unchanged ${String(s.rejudge.unchanged)}, owing ${String(s.rejudge.owing)}`}${s.memoryOnly === undefined ? "" : `, memory measured ${String(s.memoryOnly.measured)}, already ${String(s.memoryOnly.already)}, failed ${String(s.memoryOnly.failed)}, leaks not measured`}${s.adapterOnly === undefined ? "" : `, adapter run ${String(s.adapterOnly.measured)}, already ${String(s.adapterOnly.already)}, failed ${String(s.adapterOnly.failed)}`}, ${s.seconds.toFixed(1)} s`;
+    return `qualified ${String(s.qualified)}, skipped ${String(s.skipped)}, refused ${String(s.refused)}, crashed ${String(s.crashed)}, hung ${String(s.hung)}, unmeasured ${String(s.unmeasured)}, distributed ${String(s.distributed)}${s.refreshed ? `, pins refreshed ${String(s.refreshed)}` : ""}${s.rejudge === undefined ? "" : `, rejudged ${String(s.rejudge.changed)}, unchanged ${String(s.rejudge.unchanged)}, owing ${String(s.rejudge.owing)}`}${s.memoryOnly === undefined ? "" : `, memory measured ${String(s.memoryOnly.measured)}, already ${String(s.memoryOnly.already)}, failed ${String(s.memoryOnly.failed)}, leaks not measured`}${s.poolOnly === undefined ? "" : `, pool granted ${String(s.poolOnly.cores)}, off ${String(s.poolOnly.off)}, not asked ${String(s.poolOnly.notAsked)}, not run ${String(s.poolOnly.notRun)}`}${s.adapterOnly === undefined ? "" : `, adapter run ${String(s.adapterOnly.measured)}, already ${String(s.adapterOnly.already)}, failed ${String(s.adapterOnly.failed)}`}, ${s.seconds.toFixed(1)} s`;
 }
 /** The exit status `flock -n` returns when the lock is held (-E), told apart from a failure of flock itself. */
 const LOCK_HELD = 99;
@@ -1222,6 +1335,7 @@ function addSummaries(a, b) {
         ...(b.rejudge === undefined ? (a.rejudge === undefined ? {} : { rejudge: a.rejudge }) : { rejudge: b.rejudge }),
         ...(b.memoryOnly === undefined ? (a.memoryOnly === undefined ? {} : { memoryOnly: a.memoryOnly }) : { memoryOnly: b.memoryOnly }),
         ...(b.isolatedOnly === undefined ? (a.isolatedOnly === undefined ? {} : { isolatedOnly: a.isolatedOnly }) : { isolatedOnly: b.isolatedOnly }),
+        ...(b.poolOnly === undefined ? (a.poolOnly === undefined ? {} : { poolOnly: a.poolOnly }) : { poolOnly: b.poolOnly }),
         ...(b.adapterOnly === undefined ? (a.adapterOnly === undefined ? {} : { adapterOnly: a.adapterOnly }) : { adapterOnly: b.adapterOnly }),
     };
 }
@@ -1245,7 +1359,7 @@ async function runLocked(settings, options) {
     {
         const started = Date.now();
         const dirs = [...settings.clapDirs, ...settings.lv2Dirs];
-        const ctx = { settings, env, log, ...(options.pinFilesRun === undefined ? {} : { pinFilesRun: options.pinFilesRun }), ...(options.isolatedRunner === undefined ? {} : { isolatedRunner: options.isolatedRunner }) };
+        const ctx = { settings, env, log, ...(options.pinFilesRun === undefined ? {} : { pinFilesRun: options.pinFilesRun }), ...(options.isolatedRunner === undefined ? {} : { isolatedRunner: options.isolatedRunner }), ...(options.poolRunner === undefined ? {} : { poolRunner: options.poolRunner }) };
         // the pins first, before the quiet wait and any measurement: an upgrade of plugin-hostd that collects more files
         // than the pins on disk hold refuses those plugins until their pins name them (plugin-qualify#239)
         const fresh = refreshPins(ctx, readSyncState(settings.stateFile, log));
@@ -1268,6 +1382,13 @@ async function runLocked(settings, options) {
             const summary = await sendRefreshed(settings, r.state, fresh.refreshed.length, started, log);
             return { ...summary, isolatedOnly: { isolated: r.isolated, refused: r.refused, notRun: r.notRun } };
         }
+        if (options.poolOnly === true) {
+            const r = poolPass(ctx, fresh.state);
+            if (r.state !== fresh.state)
+                writeFileWhole(settings.stateFile, `${JSON.stringify(r.state, null, 1)}\n`);
+            const summary = await sendRefreshed(settings, r.state, fresh.refreshed.length, started, log);
+            return { ...summary, poolOnly: { cores: r.cores, off: r.off, notAsked: r.notAsked, notRun: r.notRun } };
+        }
         if (options.adapterOnly === true) {
             const r = adapterPass(ctx, fresh.state, { ...options.adapterPass, force: options.force === true });
             log(`adapter runs under ${Object.entries(r.versions).map(([k, v]) => `${k} ${v}`).join(", ")}`);
@@ -1323,7 +1444,8 @@ async function runLocked(settings, options) {
             for (const item of items) {
                 const recorded = recordedAsIs(item, entries[item.key]);
                 const retry = recorded.same ? entries[item.key].plugins.map(machineReason).find((r) => r !== undefined) : undefined;
-                if (recorded.same && options.force !== true && retry === undefined) {
+                const owed = recorded.same && options.force !== true && retry === undefined ? figureOwed(entries[item.key]) : undefined;
+                if (recorded.same && options.force !== true && retry === undefined && owed === undefined) {
                     if (pass === 0)
                         count.skipped += entries[item.key].plugins.length;
                     continue;
@@ -1345,6 +1467,8 @@ async function runLocked(settings, options) {
                 }
                 if (recorded.same && retry !== undefined)
                     log(`${item.key}: unmeasured last run by the machine (${retry}); measured again`);
+                if (owed !== undefined)
+                    log(`${item.key}: its record never took the ${owed} figure (a probe from before that pass); measured again`);
                 const files = recorded.files ?? digestFiles(item.root, item.files);
                 if (files === undefined) {
                     log(`${item.key}: a file of it cannot be read; skipped this run`);
@@ -1402,7 +1526,7 @@ async function runLocked(settings, options) {
             for (const f of pruneStale(settings, stateBefore, state))
                 log(`${f}: removed, its plugin is gone or changed`);
         // a plugin that was pinned and is not any more is also forgotten by a running daemon
-        const changed = [...changedPinLines(before, after), ...removedPinUris(before, after).map((uri) => `pin_clear ${uri}`)];
+        const changed = [...changedPinLines(before, after), ...removedPinUris(before, after).map(pinClearLine)];
         const sent = await sendPins(settings.hostdPort, settings.hostdFeedbackPort, changed);
         if ("unsent" in sent) {
             const why = {
@@ -1415,7 +1539,7 @@ async function runLocked(settings, options) {
         const replies = "replies" in sent ? sent.replies : [];
         for (let i = 0; i < replies.length; i++)
             if (replies[i] !== "resp 0")
-                log(`plugin-hostd answered ${replies[i]} to ${changed[i].split(" ")[1]}`);
+                log(`plugin-hostd answered ${replies[i]} to ${pinLineUri(changed[i])}`);
         const taken = replies.filter((r) => r === "resp 0").length;
         for (const [why, n] of byMachine)
             if (n > 1)