@openmixer/plugin-qualify 0.18.5 → 0.20.0

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/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-merge.ts

@@ -83,6 +83,10 @@ export function mergeProbeRuns(parts: readonly ProbeRunPart[], bound: MemoryBoun
   };
   merged["steps"] = steps;
   merged["grid"] = grid;
+  // every run's stderr is cited, not only the first's: the cell that crashed is as often a later one
+  const logs = docs.flatMap((d) => (Array.isArray(d["logs"]) ? (d["logs"] as Json[]) : []));
+  if (logs.length > 0) merged["logs"] = logs;
+  else delete merged["logs"];
   const bytes = Buffer.from(`${JSON.stringify(merged, null, 2)}\n`);
   const read = readProbeOutput(bytes.toString("utf8"));
   if (!read.ok) throw new ProbeMergeError(`the merged runs of ${first.output.plugin.id} do not read as a probe output (${read.code}): ${read.problem}`);

package/src/probe-runner.ts

@@ -165,6 +165,9 @@ export interface ProbeLoad {
 export interface ProbedTarget {
   readonly bytes: Buffer;
   readonly output: ProbeOutput;
+  /** What each run's child printed on stderr (the file the document's `logs` cites, read before the run's directory goes),
+   * one entry a run that printed anything: a crash's own words are kept with the record (#samplv1, 459 bytes lost on the Pi). */
+  readonly stderr: readonly Buffer[];
   /** The most loaded the machine was when any of the target's runs started. */
   readonly load?: ProbeLoad;
 }
@@ -226,7 +229,14 @@ 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, load };
+    let stderr: Buffer[] = [];
+    try {
+      const said = readFileSync(log);
+      if (said.length > 0) stderr = [said];
+    } catch {
+      // the runner wrote no log: the document cites none
+    }
+    return { bytes, output: read.output, load, stderr };
   } finally {
     rmSync(work, { recursive: true, force: true });
   }
@@ -246,7 +256,7 @@ export function probeTarget(target: PluginTarget, options: ProbeTargetOptions):
   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), ...(load === undefined ? {} : { load }) };
+    return { ...mergeProbeRuns(parts, options.memory), stderr: parts.flatMap((p) => p.stderr), ...(load === undefined ? {} : { load }) };
   } catch (e) {
     if (e instanceof ProbeMergeError) throw new ProbeRunnerError(e.message);
     throw e;
@@ -256,7 +266,7 @@ export function probeTarget(target: PluginTarget, options: ProbeTargetOptions):
 /** What the pass over a run's targets produced. */
 export interface ProbePass {
   /** Every probe output that was judged, with its bytes, for the qualification directory. */
-  readonly runs: readonly { readonly bytes: Buffer; readonly judgment: Judgment }[];
+  readonly runs: readonly { readonly bytes: Buffer; readonly judgment: Judgment; readonly stderr: readonly Buffer[] }[];
   readonly verdicts: readonly QualifyVerdict[];
   /** The CLAP documents of today's judge, which the pins file is taken from. */
   readonly documents: readonly RtSafetyDocument[];
@@ -292,7 +302,7 @@ export function qualifyTargets(
   const admissionRuns = options.admissions ?? SPAWNED_ADMISSIONS;
   const runEnvironment = options.env ?? process.env;
   const admissionEnv = options.admissionLv2Path === undefined ? runEnvironment : { ...runEnvironment, LV2_PATH: options.admissionLv2Path.join(":") };
-  const runs: { bytes: Buffer; judgment: Judgment }[] = [];
+  const runs: { bytes: Buffer; judgment: Judgment; stderr: readonly Buffer[] }[] = [];
   const verdicts: QualifyVerdict[] = [];
   const documents: RtSafetyDocument[] = [];
   const failures: { uri: string; problem: string }[] = [];
@@ -330,13 +340,13 @@ export function qualifyTargets(
     const judged = new Map<string, QualifyVerdict>();
     // a target's runs and documents count only when every one of its runs gave a probe output: one that
     // failed leaves the target not measured, and then nothing of it is recorded or pinned
-    const targetRuns: { bytes: Buffer; judgment: Judgment }[] = [];
+    const targetRuns: { bytes: Buffer; judgment: Judgment; stderr: readonly Buffer[] }[] = [];
     try {
       for (const { offer, profiles: forOffer } of byOffer.values()) {
         const probed = probeTarget(target, { ...options, ...measured, offer });
         const plain = judgeProbeOutput(probed.output, forOffer, { admissions });
         const judgment = { ...plain, ...(adapter === undefined ? {} : { adapter }), ...(probed.load === undefined ? {} : { load: probed.load }) };
-        targetRuns.push({ bytes: probed.bytes, judgment });
+        targetRuns.push({ bytes: probed.bytes, judgment, stderr: probed.stderr });
         for (const v of judgmentVerdicts(judgment)) judged.set(v.host, v);
       }
     } catch (e) {

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. */
@@ -390,6 +428,8 @@ export function qualificationBaseName(output: ProbeOutput): string {
 
 export const recordFileName = (output: ProbeOutput): string => `${qualificationBaseName(output)}.qualification.json`;
 export const probeCopyFileName = (output: ProbeOutput): string => `${qualificationBaseName(output)}.probe.json`;
+/** A child's stderr beside the record, named by the first 12 of the SHA-256 the probe copy's `logs` cites it by. */
+export const stderrCopyFileName = (output: ProbeOutput, sha256: string): string => `${qualificationBaseName(output)}.stderr.${sha256.slice(0, 12)}.log`;
 
 function tierOf(judgment: Judgment, host: string | undefined): TierVerdict | undefined {
   const v = judgment.hosts.find((h) => h.verdict.host === host)?.verdict;
@@ -480,6 +520,8 @@ export interface WrittenQualification {
   readonly recordPath: string;
   readonly probePath: string;
   readonly record: QualificationRecord;
+  /** The children's stderr written beside the record, one file each run that printed anything. */
+  readonly stderrPaths: readonly string[];
 }
 
 /**
@@ -492,33 +534,46 @@ export function writeQualification(
   probeBytes: Uint8Array,
   judgment: Judgment,
   notMeasured: readonly NotMeasured[] = [],
+  stderr: readonly Uint8Array[] = [],
 ): WrittenQualification {
   mkdirSync(dir, { recursive: true });
+  // the children's own words first, as the probe copy cites them: a crash's reason is kept, not only its size
+  const stderrPaths = stderr
+    .filter((s) => s.length > 0)
+    .map((s) => {
+      const path = join(dir, stderrCopyFileName(judgment.output, sha256Hex(s)));
+      writeFileWhole(path, s);
+      return path;
+    });
   const probePath = join(dir, probeCopyFileName(judgment.output));
   writeFileWhole(probePath, probeBytes);
   const copy = readFileSync(probePath);
   const record = buildQualificationRecord(judgment, { file: probeCopyFileName(judgment.output), sha256: sha256Hex(copy), bytes: copy.length }, notMeasured);
   const recordPath = join(dir, recordFileName(judgment.output));
   writeFileWhole(recordPath, `${JSON.stringify(record, null, 2)}\n`);
-  return { recordPath, probePath, record };
+  return { recordPath, probePath, record, stderrPaths };
 }
 
 /**
  * Runs that name the same binary and offer share one record file (a CLAP judged with and without the extra extensions
  * offered): their verdicts become one record over the first run's probe output, so the second is never written over the first.
  */
-export function mergeRunsByRecord<T extends { readonly bytes: Uint8Array; readonly judgment: Judgment }>(runs: readonly T[]): { bytes: Uint8Array; judgment: Judgment }[] {
-  const byName = new Map<string, { bytes: Uint8Array; judgment: Judgment }>();
+export function mergeRunsByRecord<T extends { readonly bytes: Uint8Array; readonly judgment: Judgment; readonly stderr?: readonly Uint8Array[] }>(
+  runs: readonly T[],
+): { bytes: Uint8Array; judgment: Judgment; stderr: readonly Uint8Array[] }[] {
+  // the stderr kept is the first run's, as its probe output is the copy that cites it
+  const byName = new Map<string, { bytes: Uint8Array; judgment: Judgment; stderr: readonly Uint8Array[] }>();
   for (const r of runs) {
     const name = qualificationBaseName(r.judgment.output);
     const first = byName.get(name);
     byName.set(
       name,
       first === undefined
-        ? r
+        ? { bytes: r.bytes, judgment: r.judgment, stderr: r.stderr ?? [] }
         : {
             bytes: first.bytes,
             judgment: { ...first.judgment, hosts: [...first.judgment.hosts, ...r.judgment.hosts], documents: [...first.judgment.documents, ...r.judgment.documents] },
+            stderr: first.stderr,
           },
     );
   }

package/src/qualify-declarations.ts

@@ -107,6 +107,10 @@ export const LV2_HOST_PROBE_TOOL_ENV = "OMX_LV2_HOST_PROBE";
 export const ISOLATED_SIGNAL_TOOL_ENV = "OMX_ISOLATED_SIGNAL";
 /** `native/jack-peak.c`, the level of an instrument under a held note in the adapter run (`tools/mod-host-admit.mjs`). */
 export const JACK_PEAK_TOOL_ENV = "OMX_JACK_PEAK";
+/** `native/rt-watch.c`, the interposer's window put around a JACK host's process callback: the host comparison's RT watch. */
+export const RT_WATCH_ENV = "OMX_RT_WATCH";
+/** `native/jack-compare.c`, the host comparison's ports, latency and stimulus on the JACK graph. */
+export const JACK_COMPARE_TOOL_ENV = "OMX_JACK_COMPARE";
 
 /** The file names of the native tools, in every place they are looked for. */
 export const CLAP_QUALIFY_TOOL_NAME = "clap-qualify";
@@ -115,6 +119,8 @@ export const LV2_MEASURE_TOOL_NAME = "lv2_measure";
 export const RT_INTERPOSE_NAME = "rt_interpose.so";
 export const LV2_HOST_PROBE_TOOL_NAME = "lv2_host_probe";
 export const JACK_PEAK_TOOL_NAME = "jack_peak";
+export const RT_WATCH_NAME = "rt_watch.so";
+export const JACK_COMPARE_TOOL_NAME = "jack_compare";
 
 /**
  * The ONE list of the native tools the packages install, each with the setting that names it.
@@ -127,6 +133,8 @@ export const NATIVE_TOOLS: readonly { readonly name: string; readonly env: strin
   { name: LV2_HOST_PROBE_TOOL_NAME, env: LV2_HOST_PROBE_TOOL_ENV },
   { name: ISOLATED_SIGNAL_TOOL_NAME, env: ISOLATED_SIGNAL_TOOL_ENV },
   { name: JACK_PEAK_TOOL_NAME, env: JACK_PEAK_TOOL_ENV },
+  { name: RT_WATCH_NAME, env: RT_WATCH_ENV },
+  { name: JACK_COMPARE_TOOL_NAME, env: JACK_COMPARE_TOOL_ENV },
 ];
 
 /**