@openmixer/plugin-qualify 0.18.4 → 0.19.1

package/src/distributed-records.ts

@@ -29,9 +29,6 @@ export const DISTRIBUTED_DIR_SYSTEM = "/usr/share/omx/qualification";
 export const DISTRIBUTED_PROVENANCE_FILE = "provenance.json";
 export const DISTRIBUTED_PROVENANCE_SCHEMA = "plugin-qualify.distributed-provenance/1";
 
-/** The first plugin-qualify that reads the layer: what a package of records depends on. */
-export const DISTRIBUTED_LAYER_SINCE = "0.17.0";
-
 /** Where the records of a set come from. The keys below are always there; the rest is what the builder was given. */
 export interface DistributedProvenance {
   readonly schema: typeof DISTRIBUTED_PROVENANCE_SCHEMA;

package/src/host-admission.ts

@@ -45,10 +45,10 @@ export function runDecides(profile: HostProfile, format: string, admission: Host
 /** What running the plugin under one host came to. */
 export interface HostAdmission {
   readonly host: AdmittedHost | typeof ADAPTER_HOST;
-  /** False when the host could not be run (not installed): there is no evidence either way. */
+  /** False when the host could not be run (not installed, no JACK client): there is no evidence either way. */
   readonly measured: boolean;
   readonly admitted: boolean;
-  /** Why not: `<host>.resp-<n>`, `<host>.signal-<SIG>`, `mod-host.died-on-add`, `jalv.unknown-port-type`, `<host>.not-installed`, … */
+  /** Why not: `<host>.resp-<n>`, `<host>.signal-<SIG>`, `mod-host.died-on-add`, `jalv.unknown-port-type`, `<host>.not-installed`, `<host>.no-jack-client`, … */
   readonly code?: string;
   readonly params: Readonly<Record<string, string | number>>;
 }
@@ -103,6 +103,12 @@ export function admissionRating(admission: HostAdmission): "unsuitable" | "unkno
   return !admission.measured || UNPROVEN_SOUND.includes(admission.code ?? "") ? "unknown" : "unsuitable";
 }
 
+/**
+ * ERR_JACK_CLIENT_CREATION and ERR_JACK_CLIENT_ACTIVATION (mod-host's host-errors.h): the add could not get a JACK client,
+ * which says nothing of the plugin. omx-clap-host opens JACK at the first add since 0.26.1, so a host with no server answers these.
+ */
+const JACK_CLIENT_RESPS: readonly number[] = [-201, -202];
+
 /** The verdict of a run of a host that speaks mod-host's protocol: the first step that did not answer `resp 0` decides. */
 export function classifyProtocolRun(host: ProtocolHost, run: ModHostRun): HostAdmission {
   if (!run.installed) return notInstalled(host);
@@ -114,6 +120,7 @@ export function classifyProtocolRun(host: ProtocolHost, run: ModHostRun): HostAd
       return s.cmd === "add" ? refused(host, "died-on-add", { how: s.died }) : refused(host, "died", { step: s.cmd, how: s.died });
     }
     if (s.resp === undefined) return refused(host, "no-answer", { step: s.cmd });
+    if (s.cmd === "add" && s.resp !== undefined && JACK_CLIENT_RESPS.includes(s.resp)) return { host, measured: false, admitted: false, code: `${host}.no-jack-client`, params: { resp: s.resp } };
     // the host answers an error as a negative number (`resp -102`); the code carries its magnitude
     if (s.resp < 0) return refused(host, `resp-${-s.resp}`, { step: s.cmd, resp: s.resp });
   }

package/src/hosting-codes.generated.ts

@@ -62,6 +62,7 @@ export const HOSTING_CODE = Object.freeze({
   "stabilityBelowFloor": "hosting.stability.cycles-below-floor",
   "stabilityCrashUnattributed": "hosting.stability.crash-unattributed",
   "stabilityCrashedAttributed": "hosting.stability.crashed-attributed-plugin",
+  "stabilityCalleeSavedClobbered": "hosting.stability.callee-saved-clobbered",
   "stabilityCrashedLive": "hosting.stability.crashed-live-on-this-rig",
   "stabilityLinksGuiToolkit": "hosting.stability.links-gui-toolkit",
   "stabilitySoakFailedAtRate": "hosting.stability.soak-failed-at-rate",

package/src/hosting-suitability.ts

@@ -23,6 +23,7 @@ import {
   type SuitabilityRating,
 } from "./rating.js";
 import type {
+  AbiReading,
   FeaturesMeasurement,
   LifecycleReading,
   RtSafetyMeasurement,
@@ -299,6 +300,8 @@ export function attributeCrash(
  */
 export interface PluginStabilityMeasurement {
   readonly lifecycle?: LifecycleReading;
+  /** Whether a plugin call returned with a callee-saved register changed (the measurer's guard put it back). */
+  readonly abi?: AbiReading;
   readonly threads?: ThreadReading;
   readonly crashes?: readonly ObservedCrash[];
   /** A continuous render per rate with the controls swept — judged at EVERY rate it ran. */
@@ -587,6 +590,17 @@ export function stabilityReasons(
       reason("stability", "objective", "unsuitable", HOSTING_CODE.stabilityCrashedLive, {}),
     );
   }
+  // a plugin call that returned with a callee-saved register changed: the host's guard puts it back, but not the other
+  // members' state in the same process, so the plugin is a hosting mode, never a refusal: a worker of its own
+  if (m.abi?.clobbered === true) {
+    out.push(
+      reason("stability", "objective", "conditional", HOSTING_CODE.stabilityCalleeSavedClobbered, {
+        registers: (m.abi.registers ?? []).join(","),
+        call: m.abi.call ?? "",
+        block: m.abi.block ?? 0,
+      }),
+    );
+  }
   const attributions = (m.crashes ?? []).map((c) => attributeCrash(c, CRASH_SIGNATURES, pluginBinary));
   if (attributions.includes("plugin")) {
     out.push(reason("stability", "objective", "unsuitable", HOSTING_CODE.stabilityCrashedAttributed));

package/src/index.ts

@@ -39,3 +39,4 @@ export * from "./host-admission.js";
 export * from "./history-file.js";
 export * from "./history-adjust.js";
 export * from "./adjust-cli.js";
+export * from "./compare.js";

package/src/jack-registry.ts

@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Copyright (C) 2026 Pau Aliagas <linuxnow@gmail.com>
+/**
+ * JACK's table of its servers, /dev/shm/jack-shm-registry: a header, then eight rows of a pid and a name
+ * (`jack-<uid>:<server>:`). A server that is killed never clears its row, and once the eight are taken no server starts.
+ * The adapter pass starts and stops servers of its own, `omx-qualify-<pid>-<quantum>`; a row of one of those whose
+ * process is gone is freed (pid 0, name empty) before the next start, as jackd frees its own row when it ends well.
+ * Rows of any other server are never touched, and a file of another layout is left as it is.
+ */
+import { closeSync, existsSync, openSync, readSync, writeSync } from "node:fs";
+
+export const JACK_REGISTRY = "/dev/shm/jack-shm-registry";
+/** the header jack2 writes before the server rows, and the size of a row: a pid, then the name */
+export const JACK_REGISTRY_HEADER = 24;
+export const JACK_REGISTRY_ENTRY = 264;
+const ROWS = 8;
+const MAGIC = "KCAJ";
+const OWN = ":omx-qualify-";
+
+const alive = (pid: number): boolean => existsSync(`/proc/${String(pid)}`);
+
+/** Frees the rows of the pass's own servers that are gone; the names freed, in the table's order. */
+export function freeDeadJackSlots(path: string = process.env["OMX_JACK_REGISTRY"] ?? JACK_REGISTRY): string[] {
+  const freed: string[] = [];
+  let fd: number;
+  try {
+    fd = openSync(path, "r+");
+  } catch {
+    return freed;
+  }
+  try {
+    const head = Buffer.alloc(JACK_REGISTRY_HEADER + ROWS * JACK_REGISTRY_ENTRY);
+    if (readSync(fd, head, 0, head.length, 0) !== head.length) return freed;
+    // the layout this code knows, or nothing is touched
+    if (head.toString("latin1", 0, 4) !== MAGIC || head.readUInt32LE(16) !== JACK_REGISTRY_HEADER + ROWS * JACK_REGISTRY_ENTRY) return freed;
+    for (let k = 0; k < ROWS; k++) {
+      const at = JACK_REGISTRY_HEADER + k * JACK_REGISTRY_ENTRY;
+      const pid = head.readInt32LE(at);
+      const name = head.toString("latin1", at + 4, at + JACK_REGISTRY_ENTRY).split("\0")[0] ?? "";
+      if (pid <= 0 || !name.includes(OWN) || alive(pid)) continue;
+      writeSync(fd, Buffer.alloc(4), 0, 4, at);
+      writeSync(fd, Buffer.alloc(1), 0, 1, at + 4);
+      freed.push(name);
+    }
+  } finally {
+    closeSync(fd);
+  }
+  return freed;
+}

package/src/lv2-loader.ts

@@ -3,8 +3,8 @@
 /**
  * The LV2 implementation of the one discovery seam (`loader.ts`, spec §7). A target that names an
  * existing directory is a bundle: every subject its `manifest.ttl` declares `a lv2:Plugin` is a
- * plugin, with its `lv2:binary` basename. Anything else shaped like a URI (`scheme:rest`) is one
- * plugin. A path that does not exist is not this loader's — the CLI refuses it by name.
+ * plugin, with its `lv2:binary` basename. Anything with a scheme (`scheme:rest`, other than `file:`) is one
+ * plugin, looked up by URI; a bare or `file:` argument is a path. A path that does not exist is not this loader's — the CLI refuses it by name.
  *
  * The manifest is read as plugin-hostd reads it to pin a plugin: statements of IRIs and prefixed names, with blank
  * nodes and collections stepped over, not a whole Turtle parser. A plugin is a subject typed `lv2:Plugin`; its files
@@ -169,8 +169,9 @@ export const lv2Loader: PluginLoader = {
         ...(p.binary === undefined ? {} : { binary: p.binary }),
       }));
     }
-    if (target.includes("/") || target.endsWith(".lv2")) return undefined; // a path that is not there
-    return URI_SHAPE.test(target) ? [{ format: "lv2", uri: target }] : undefined;
+    // A scheme (http, https, urn, ...) makes the argument a URI; a bare or `file:` argument is a path, and one that is not there is not this loader's.
+    if (!/^file:/i.test(target) && URI_SHAPE.test(target) && !/^[A-Za-z]:[\\/]/.test(target)) return [{ format: "lv2", uri: target }];
+    return undefined;
   },
 };
 

package/src/measurement/format.ts

@@ -425,8 +425,22 @@ export interface SoakReading {
 }
 
 /** Everything one run learned about one plugin SURVIVING. Readable when it has a lifecycle. */
+/**
+ * The plugin calls the measurer made through omx-clap-core's guard: whether one returned with a callee-saved register
+ * changed, and for the first, the registers, the plugin function and the run block; calls counts all that did. The
+ * guard put them back, so the measurement is whole; a plugin that clobbered runs only in a worker of its own.
+ */
+export interface AbiReading {
+  readonly clobbered: boolean;
+  readonly registers?: readonly string[];
+  readonly call?: string;
+  readonly block?: number;
+  readonly calls?: number;
+}
+
 export interface StabilityMeasurement {
   readonly lifecycle?: LifecycleReading;
+  readonly abi?: AbiReading;
   readonly threads?: ThreadReading;
   readonly crashes?: readonly CrashReading[];
   readonly soak?: SoakReading;
@@ -1078,10 +1092,28 @@ function readSoak(value: unknown): SoakReading | undefined {
   return { sweptParams, perRate: readRateMap(value.perRate, readSoakAtRate) };
 }
 
+/** The measurer's abi field: a boolean clobbered, and with it the first clobber's registers, call and block. */
+export function readAbi(value: unknown): AbiReading | undefined {
+  if (!isRecord(value)) return undefined;
+  const clobbered = booleanValue(value.clobbered);
+  if (clobbered === undefined) return undefined;
+  const registers = Array.isArray(value.registers)
+    ? value.registers.filter((r): r is string => typeof r === "string" && r.length > 0)
+    : undefined;
+  return {
+    clobbered,
+    ...optional("registers", clobbered ? registers : undefined),
+    ...optional("call", clobbered ? nonEmptyString(value.call) : undefined),
+    ...optional("block", clobbered ? finiteNumber(value.block) : undefined),
+    ...optional("calls", clobbered ? finiteNumber(value.calls) : undefined),
+  };
+}
+
 function readStability(value: unknown): StabilityMeasurement | undefined {
   if (!isRecord(value)) return undefined;
   return {
     ...optional("lifecycle", readLifecycle(value.lifecycle)),
+    ...optional("abi", readAbi(value.abi)),
     ...optional("threads", readThreads(value.threads)),
     ...optional("crashes", mapArray(value.crashes, readCrash)),
     ...optional("soak", readSoak(value.soak)),

package/src/measurement/sweep-jsonl.ts

@@ -29,7 +29,7 @@ import type {
   SoakReading,
   StabilityMeasurement,
 } from "./format.js";
-import { readIntegrity, readLifecycle, readNoteSweep, readSoakAtRate, readThreads } from "./format.js";
+import { readAbi, readIntegrity, readLifecycle, readNoteSweep, readSoakAtRate, readThreads } from "./format.js";
 import { booleanValue, finiteNumber, isRecord, mapArray, nonEmptyString, optional, positiveNumber } from "./guards.js";
 
 /** The sweep's three passes, each a list of parsed JSONL lines. Only `measurements` is required. */
@@ -82,8 +82,12 @@ function stabilityOf(
     (c): c is CrashReading => c !== undefined,
   );
   const soak = soakRow === undefined ? undefined : soakOf(soakRow);
+  // either pass's clobber is the plugin's: the deep pass runs the same plugin longer
+  const abis = [readAbi(quick.abi), deep === undefined ? undefined : readAbi(deep.abi)];
+  const abi = abis.find((a) => a?.clobbered === true) ?? abis.find((a) => a !== undefined);
   return {
     lifecycle,
+    ...optional("abi", abi),
     ...optional("threads", threads),
     crashes,
     ...optional("soak", soak),

package/src/measurement-grid.ts

@@ -3,7 +3,7 @@
 /**
  * The measurement grid (#193): the cells, each one rate and one quantum, a plugin is measured at, and the runs of the
  * probe runner that measure them. A host is judged at its own cell, so the grid a run takes is chosen from the hosts it
- * judges; README "The measurement grid" states the three ways of choosing it and the order the cells are taken in.
+ * judges; docs/overview.md "The measurement grid" states the three ways of choosing it and the order the cells are taken in.
  *
  * Pure: no file, no process. `probe-runner.ts` runs what `runnerInvocations` plans.
  */

package/src/pins-file.ts

@@ -5,7 +5,10 @@
  * pin store's import): one line per qualified plugin, the SAME line as hostd's `pin_set` verb, with the
  * qualification verdict as a last word.
  *
- *     pin_set <uri> <path>=<sha256>[,<path>=<sha256>...] <scheme>:<sha256> [verdict=<word>]
+ *     pin_set <uri> <path>=<sha256>[,<path>=<sha256>...] <scheme>:<sha256> [verdict=<word>] [pool=<word>]
+ *
+ * A word is the protocol's (plugin-hostd-protocol's `word`): bare, or in double quotes when it holds a space, with `\"`
+ * for a quote inside. A CLAP plugin under a directory with a space in its name has a uri with a space in it: one quoted word.
  *
  * The digests and the layout are the prober's, raw (`IntegrityMeasurement`); nothing here computes a hash. A plugin
  * whose run took no whole pin has no line: a pins file never holds a partial pin. The grammar is plugin-hostd's
@@ -26,6 +29,13 @@ export const PIN_VERB = "pin_set";
 /** The key of the verdict word, hostd's `PHD_PIN_VERDICT_KEY`. */
 export const PIN_VERDICT_KEY = "verdict=";
 
+/** The key of the pool word, hostd's `PHD_PIN_POOL_KEY`. */
+export const PIN_POOL_KEY = "pool=";
+
+/** The pool words hostd knows (`PHD_PIN_POOLS`): `cores` starts the plugin's worker with the CLAP thread pool on, `off` says it was measured and gains nothing. */
+export const PIN_POOLS = ["cores", "off"] as const;
+export type PinPool = (typeof PIN_POOLS)[number];
+
 /** The verdict words hostd knows (`PHD_PIN_VERDICTS`). */
 export const PIN_VERDICTS = ["in-process", "isolated", "refused"] as const;
 export type PinVerdict = (typeof PIN_VERDICTS)[number];
@@ -54,19 +64,84 @@ export interface PinEntry {
   readonly uri: string;
   readonly integrity: IntegrityMeasurement;
   readonly verdict?: PinVerdict;
+  /** What the pool step measured: the pool is the plugin's qualification to give, never assumed. A refused pin carries none. */
+  readonly pool?: PinPool;
 }
 
-/** The line of one pin, or `undefined` when the integrity block is not a whole pin. A uri with whitespace in it would be read back as more words: it is refused, by name. */
-export function pinLine(entry: PinEntry): string | undefined {
-  const spaced = [entry.uri, ...(entry.integrity.files ?? []).map((f) => f.path)].find((w) => /\s/.test(w));
-  if (spaced !== undefined) {
-    throw new Error(`${entry.uri}: ${JSON.stringify(spaced)} has whitespace in it and cannot be a word of a pin line`);
+/** A word of the protocol, `word` in its grammar: bare, or quoted when it holds a space or a double quote. A control character cannot be a word, nor can a quoted word end in a backslash (it would read as an escaped quote). */
+export function pinWord(value: string): string {
+  if (value === "") throw new Error("an empty word cannot be a word of a pin line");
+  // eslint-disable-next-line no-control-regex
+  if (/[\x00-\x1f\x7f]/.test(value)) throw new Error(`${JSON.stringify(value)} has a control character in it and cannot be a word of a pin line`);
+  if (!/[ "]/.test(value)) return value;
+  if (value.endsWith("\\")) throw new Error(`${JSON.stringify(value)} ends in a backslash and cannot be a quoted word of a pin line`);
+  return `"${value.replaceAll('"', '\\"')}"`;
+}
+
+/** The words of a line, the protocol's: a quoted word with its quotes taken off and its `\"` read as a quote. */
+export function pinWords(line: string): string[] {
+  const words: string[] = [];
+  let i = 0;
+  while (i < line.length) {
+    if (line[i] === " " || line[i] === "\t" || line[i] === "\r") {
+      i++;
+    } else if (line[i] === '"') {
+      let word = "";
+      for (i++; ; i++) {
+        if (i >= line.length) throw new Error("a quote is not closed");
+        if (line[i] === "\\" && line[i + 1] === '"') {
+          word += '"';
+          i++;
+        } else if (line[i] === '"') {
+          i++;
+          break;
+        } else {
+          word += line[i];
+        }
+      }
+      if (i < line.length && line[i] !== " " && line[i] !== "\t" && line[i] !== "\r") throw new Error("a quoted word is followed by more of the word");
+      words.push(word);
+    } else {
+      const start = i;
+      while (i < line.length && line[i] !== " " && line[i] !== "\t" && line[i] !== "\r") {
+        if (line[i] === '"') throw new Error("a quote inside a bare word");
+        i++;
+      }
+      words.push(line.slice(start, i));
+    }
   }
+  return words;
+}
+
+/** The uri of a pin line (or of a `pin_clear` line), with the verb or without: its first word after the verb. */
+export function pinLineUri(line: string): string | undefined {
+  const words = pinWords(line);
+  if (words[0] === PIN_VERB || words[0] === "pin_clear") words.shift();
+  return words[0];
+}
+
+/** The line that takes a pin away: the uri is one word. */
+export function pinClearLine(uri: string): string {
+  return `pin_clear ${pinWord(uri)}`;
+}
+
+/**
+ * The line of one pin, or `undefined` when the integrity block is not a whole pin. The uri is one word, quoted when it
+ * holds a space. A file path inside the bundle cannot hold whitespace, a comma or an equals sign (the protocol's PATH
+ * limit: they are the separators of the words of a pin), so a plugin with such a file has no pin, refused by name.
+ */
+export function pinLine(entry: PinEntry): string | undefined {
   const { files, layout } = entry.integrity;
+  const uri = pinWord(entry.uri);
+  for (const f of files ?? []) {
+    const bad = /[,="\s]/.exec(f.path);
+    if (bad !== null) throw new Error(`${entry.uri}: the file ${JSON.stringify(f.path)} holds ${JSON.stringify(bad[0])}, which a pinned path cannot (a separator of the words of a pin, or a quote)`);
+  }
   if (files === undefined || files.length === 0 || layout === undefined) return undefined;
   const list = files.map((f) => `${f.path}=${f.sha256}`).join(",");
   const verdict = entry.verdict === undefined ? "" : ` ${PIN_VERDICT_KEY}${entry.verdict}`;
-  return `${PIN_VERB} ${entry.uri} ${list} ${layout.scheme}:${layout.sha256}${verdict}`;
+  const pool = entry.pool === undefined || entry.verdict === "refused" ? "" : ` ${PIN_POOL_KEY}${entry.pool}`;
+  return `${PIN_VERB} ${uri} ${list} ${layout.scheme}:${layout.sha256}${verdict}${pool}`;
 }
 
 /** hostd's uri of a CLAP plugin the prober loaded: its file as it was handed, made absolute, and its id. */
@@ -82,7 +157,7 @@ export interface PinsFile {
   readonly written: readonly string[];
   /** The uris of plugins that took no whole pin: they have no line. */
   readonly skipped: readonly string[];
-  /** The uris refused because a word of their line has whitespace in it, each with the reason: they have no line. */
+  /** The uris refused because a word of their line cannot be a word (a control character), each with the reason: they have no line. */
   readonly refused: readonly { readonly uri: string; readonly problem: string }[];
 }
 
@@ -175,6 +250,7 @@ export interface ParsedPin {
   readonly files: readonly { readonly path: string; readonly sha256: string }[];
   readonly layout: { readonly scheme: string; readonly sha256: string };
   readonly verdict?: PinVerdict;
+  readonly pool?: PinPool;
 }
 
 const HEX = /^[0-9a-f]{64}$/;
@@ -185,11 +261,11 @@ const HEX = /^[0-9a-f]{64}$/;
  * 64 lowercase hex digits, a layout without a scheme, a verdict outside the vocabulary, a path named twice).
  */
 export function parsePinLine(line: string): ParsedPin | undefined {
-  const words = line.trim().split(/\s+/).filter((w) => w !== "");
+  const words = pinWords(line);
   if (words.length === 0 || words[0]!.startsWith("#")) return undefined;
   if (words[0] === PIN_VERB) words.shift();
-  if (words.length !== 3 && words.length !== 4) throw new Error(`a pin line has 3 or 4 words, not ${words.length}`);
-  const [uri, list, layout, verdictWord] = words as [string, string, string, string | undefined];
+  if (words.length < 3 || words.length > 5) throw new Error(`a pin line has 3 to 5 words, not ${words.length}`);
+  const [uri, list, layout, ...optional] = words as [string, string, string, ...string[]];
   const files = list.split(",").map((item) => {
     const eq = item.lastIndexOf("=");
     if (eq < 0) throw new Error(`${item}: no =`);
@@ -205,10 +281,27 @@ export function parsePinLine(line: string): ParsedPin | undefined {
   const colon = layout.lastIndexOf(":");
   if (colon <= 0 || !HEX.test(layout.slice(colon + 1))) throw new Error(`${layout}: not a layout pin`);
   let verdict: PinVerdict | undefined;
-  if (verdictWord !== undefined) {
-    const word = verdictWord.startsWith(PIN_VERDICT_KEY) ? verdictWord.slice(PIN_VERDICT_KEY.length) : "";
-    if (!(PIN_VERDICTS as readonly string[]).includes(word)) throw new Error(`${verdictWord}: not a verdict`);
-    verdict = word as PinVerdict;
+  let pool: PinPool | undefined;
+  for (const word of optional) {
+    if (word.startsWith(PIN_VERDICT_KEY)) {
+      if (verdict !== undefined) throw new Error(`${word}: a second verdict`);
+      const value = word.slice(PIN_VERDICT_KEY.length);
+      if (!(PIN_VERDICTS as readonly string[]).includes(value)) throw new Error(`${word}: not a verdict`);
+      verdict = value as PinVerdict;
+    } else if (word.startsWith(PIN_POOL_KEY)) {
+      if (pool !== undefined) throw new Error(`${word}: a second pool word`);
+      const value = word.slice(PIN_POOL_KEY.length);
+      if (!(PIN_POOLS as readonly string[]).includes(value)) throw new Error(`${word}: not a pool word`);
+      pool = value as PinPool;
+    } else {
+      throw new Error(`${word}: not a word of a pin`);
+    }
   }
-  return { uri, files, layout: { scheme: layout.slice(0, colon), sha256: layout.slice(colon + 1) }, ...(verdict === undefined ? {} : { verdict }) };
+  return {
+    uri,
+    files,
+    layout: { scheme: layout.slice(0, colon), sha256: layout.slice(colon + 1) },
+    ...(verdict === undefined ? {} : { verdict }),
+    ...(pool === undefined ? {} : { pool }),
+  };
 }

package/src/probe-judge.ts

@@ -197,6 +197,8 @@ export interface HostJudgment {
 
 export interface Judgment {
   readonly output: ProbeOutput;
+  /** How loaded the machine was when the probe started (probe-runner's ProbeLoad); absent when not taken. */
+  readonly load?: { readonly loadavg1: number; readonly cores: number };
   /** An LV2 plugin's run under plugin-hostd's LV2 adapter, beside the verdicts (plugin-qualify#223). */
   readonly adapter?: HostAdmission;
   readonly hosts: readonly HostJudgment[];

package/src/probe-runner.ts

@@ -13,7 +13,7 @@
  */
 import { spawnSync } from "node:child_process";
 import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
+import { availableParallelism, loadavg, tmpdir } from "node:os";
 import { join } from "node:path";
 
 import { ClapQualifyError, clapQualifyTools, proberOffer, type RtSafetyDocument } from "./clap-qualify.js";
@@ -155,11 +155,22 @@ export function lv2RunnerArgs(
 }
 
 /** One probe output and the bytes it was read from (the bytes are what gets copied beside the record). */
+/** How loaded the machine was when a probe started: the one-minute load average and the cores, so that a crash under a
+ * full machine can be told from one on an idle one. */
+export interface ProbeLoad {
+  readonly loadavg1: number;
+  readonly cores: number;
+}
+
 export interface ProbedTarget {
   readonly bytes: Buffer;
   readonly output: ProbeOutput;
+  /** The most loaded the machine was when any of the target's runs started. */
+  readonly load?: ProbeLoad;
 }
 
+const loadNow = (): ProbeLoad => ({ loadavg1: Math.round(loadavg()[0]! * 100) / 100, cores: availableParallelism() });
+
 function runOne(target: PluginTarget, options: ProbeTargetOptions, invocation: RunnerInvocation): ProbedTarget {
   const env = options.env ?? process.env;
   const tool = probeRunnerTool(env);
@@ -193,6 +204,7 @@ function runOne(target: PluginTarget, options: ProbeTargetOptions, invocation: R
     }
     // under a bound, the interposer ends the child the moment an allocation is refused, with the status that names it
     if (options.memory !== undefined) runEnv = { ...runEnv, [MEMORY_BOUND_EXIT_ENV]: "1" };
+    const load = loadNow();
     const r = (options.run ?? spawnRunner)(tool, args, runEnv);
     if (r.error !== undefined) {
       throw new ProbeRunnerError(`cannot run the probe runner "${tool}" (${r.error.message}): install plugin-hostd or set ${PROBE_RUNNER_ENV} to plugin-hostd-probe`);
@@ -214,7 +226,7 @@ function runOne(target: PluginTarget, options: ProbeTargetOptions, invocation: R
     if (read.output.plugin.id !== expectedId) {
       throw new ProbeRunnerError(`${tool} measured ${read.output.plugin.id} when asked for ${expectedId}: not judged as the plugin asked for`);
     }
-    return { bytes, output: read.output };
+    return { bytes, output: read.output, load };
   } finally {
     rmSync(work, { recursive: true, force: true });
   }
@@ -231,8 +243,10 @@ export function targetCells(options: Pick<ProbeTargetOptions, "rates" | "cells">
  */
 export function probeTarget(target: PluginTarget, options: ProbeTargetOptions): ProbedTarget {
   const parts = runnerInvocations(target.format, targetCells(options)).map((invocation) => ({ ...runOne(target, options, invocation), invocation }));
+  const loads = parts.flatMap((p) => (p.load === undefined ? [] : [p.load]));
+  const load = loads.length === 0 ? undefined : loads.reduce((a, b) => (b.loadavg1 > a.loadavg1 ? b : a));
   try {
-    return mergeProbeRuns(parts, options.memory);
+    return { ...mergeProbeRuns(parts, options.memory), ...(load === undefined ? {} : { load }) };
   } catch (e) {
     if (e instanceof ProbeMergeError) throw new ProbeRunnerError(e.message);
     throw e;
@@ -321,7 +335,7 @@ export function qualifyTargets(
       for (const { offer, profiles: forOffer } of byOffer.values()) {
         const probed = probeTarget(target, { ...options, ...measured, offer });
         const plain = judgeProbeOutput(probed.output, forOffer, { admissions });
-        const judgment = adapter === undefined ? plain : { ...plain, adapter };
+        const judgment = { ...plain, ...(adapter === undefined ? {} : { adapter }), ...(probed.load === undefined ? {} : { load: probed.load }) };
         targetRuns.push({ bytes: probed.bytes, judgment });
         for (const v of judgmentVerdicts(judgment)) judged.set(v.host, v);
       }

package/src/qualification-record.ts

@@ -76,6 +76,23 @@ export interface IsolatedFigures {
   readonly midiInputsLinked?: number;
 }
 
+/**
+ * What the pool step measured. With real helper threads under the interposer: the allocations, locks and system calls
+ * counted while the plugin's tasks ran on them, and how many tasks the helpers ran. Under a real host's pool on a private
+ * server: the server's DSP load and the xruns of the window without the thread pool and of the one with it.
+ */
+export interface PoolFigures {
+  readonly allocationsOn?: number;
+  readonly locksOn?: number;
+  readonly syscallsOn?: number;
+  readonly tasksOnHelpers?: number;
+  /** Percent of the cycle the whole graph took, over the last third of the window. */
+  readonly dspLoadOff?: number;
+  readonly dspLoadOn?: number;
+  readonly xrunsOff?: number;
+  readonly xrunsOn?: number;
+}
+
 /** One step of a plugin's pass and how it ended. */
 export interface RunStep {
   readonly step: string;
@@ -83,6 +100,8 @@ export interface RunStep {
   readonly code?: string;
   readonly detail?: string;
   readonly figures?: IsolatedFigures;
+  /** The pool step's figures. */
+  readonly pool?: PoolFigures;
 }
 
 /** The pass that judged a record: its id, and every step that ran. */
@@ -150,6 +169,25 @@ export function unmeasuredFigures(output: ProbeOutput): readonly UnmeasuredFigur
     }));
 }
 
+/**
+ * Whether the run that wrote the record never took the latency figure: the probe ended well and measured a point, yet no
+ * point holds a latency and none is named unmeasured. That is a probe from before the latency pass (plugin-hostd-probe
+ * 0.12 ran no latency pass on an LV2 plugin): an instrument's note onset, or an effect's impulse, was never asked for, so a
+ * reader shows "latency unknown" for a figure today's probe takes. Such a record owes a measurement; it is never read as
+ * a plugin with no latency.
+ */
+export function latencyNeverTaken(record: Pick<QualificationRecord, "probe" | "measurements">): boolean {
+  if (record.probe?.outcome !== PROBE_OK) return false;
+  const ok = (record.measurements?.grid ?? []).filter((p) => p.outcome === PROBE_OK);
+  if (ok.length === 0) return false;
+  if ((record.measurements.unmeasured ?? []).some((u) => u.dimension === "latency")) return false;
+  // a point's latency is a figure, or the reason the probe gave for none; `not-attempted` with no step is the older probe's silence
+  return !ok.some((p) => {
+    const l = p.latency as Partial<{ measuredFrames: number; unmeasuredReason: string }> | undefined;
+    return l !== undefined && (l.measuredFrames !== undefined || (l.unmeasuredReason !== undefined && l.unmeasuredReason !== word("notAttempted")));
+  });
+}
+
 /** A cell's latency when the run took no figure: the contract's unmeasured word and the hosting code a reader classifies by. */
 export interface UnmeasuredLatency {
   /** The figure the plugin declared (LV2 latency port, CLAP latency extension) when it loaded but the probe did not measure. */
@@ -343,9 +381,38 @@ export interface QualificationRecord {
     readonly machineClass: Readonly<Record<string, string | boolean>>;
     /** Whether the machine met the protocol's optimised profile: a figure that did not is not a reference figure. */
     readonly meetsProtocol: boolean;
+    /** Each step whose child did not end well: the signal that killed it or the status it exited with, so a crash is
+     * told from the runner's own kill (a deadline or memory kill is SIGKILL). Absent when every child ended well. */
+    readonly ends?: readonly ProbeEnd[];
+    /** How loaded the machine was when the probe started; absent on a record written before it was taken. */
+    readonly load?: { readonly loadavg1: number; readonly cores: number };
   };
 }
 
+/** How one step's child ended, when not well. */
+export interface ProbeEnd {
+  readonly step: string;
+  readonly outcome: string;
+  readonly rate?: number;
+  readonly quantum?: number;
+  readonly signal?: string;
+  readonly exitStatus?: number;
+}
+
+/** The steps of a probe output whose child was killed by a signal or exited with a status other than 0. */
+export function probeEnds(output: ProbeOutput): readonly ProbeEnd[] {
+  return output.steps
+    .filter((s) => (s.signal !== undefined && s.signal !== null && s.signal !== "") || (s.exitStatus !== undefined && s.exitStatus !== 0))
+    .map((s) => ({
+      step: s.step,
+      outcome: s.outcome,
+      ...(s.rate === undefined ? {} : { rate: s.rate }),
+      ...(s.quantum === undefined ? {} : { quantum: s.quantum }),
+      ...(s.signal ? { signal: s.signal } : {}),
+      ...(s.exitStatus === undefined || s.exitStatus === 0 ? {} : { exitStatus: s.exitStatus }),
+    }));
+}
+
 /** One dimension a run did not measure, and the code that says so. */
 export interface NotMeasured {
   readonly dimension: string;
@@ -431,6 +498,8 @@ export function buildQualificationRecord(
       complete: o.run.complete,
       machineClass: o.machine.class,
       meetsProtocol: o.machine.profile.meetsProtocol,
+      ...(probeEnds(o).length === 0 ? {} : { ends: probeEnds(o) }),
+      ...(judgment.load === undefined ? {} : { load: judgment.load }),
     },
   };
 }