@openmixer/plugin-qualify 0.18.5 → 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/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/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. */

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 },
 ];
 
 /**

package/src/qualify-isolated.ts

@@ -18,9 +18,10 @@ import { basename, join } from "node:path";
 
 import { ADAPTER_PASS_CELLS, startPrivateJack, type JackStarter } from "./qualify-adapter-pass.js";
 import type { GridCell } from "./measurement-grid.js";
-import type { PinEntry } from "./pins-file.js";
+import { clapPinUri, type PinEntry } from "./pins-file.js";
 import { PROBE_OK, readProbeOutput } from "./probe-output.js";
-import type { IsolatedFigures, QualificationRecord, RunBlock, RunStep } from "./qualification-record.js";
+import { HOSTING_CODE } from "./hosting-codes.js";
+import type { IsolatedFigures, QualificationRecord, RecordVerdict, RunBlock, RunStep } from "./qualification-record.js";
 import { ISOLATED_SIGNAL_TOOL_ENV, ISOLATED_SIGNAL_TOOL_NAME } from "./qualify-declarations.js";
 import { locateNativeTool, toolsDir } from "./tool-paths.js";
 import { writeFileWhole } from "./whole-file.js";
@@ -97,9 +98,34 @@ function figuresOf(run: IsolatedRunFacts): IsolatedFigures | undefined {
   };
 }
 
-/** Whether a record's outcome calls for the isolated step: rated `conditional` by some host, or a probe that crashed or hung. */
+/**
+ * A verdict whose only gap is memory nobody measured: it reads `unknown` and every reason that is not `suitable` is
+ * `hosting.memory.unmeasured`. Nothing says the plugin is unfit, so it is hosted in a worker of its own until its
+ * footprint is measured, and the isolated step is what shows it running alone.
+ */
+export function memoryGapOnly(v: Pick<RecordVerdict, "measured" | "rating" | "reasons">): boolean {
+  if (!v.measured || v.rating !== "unknown") return false;
+  const open = v.reasons.filter((r) => r.rating !== "suitable");
+  return open.length > 0 && open.every((r) => r.code === HOSTING_CODE.memoryUnmeasured);
+}
+
+/** Whether a record's outcome calls for the isolated step: rated `conditional` by some host, a memory gap and nothing else, or a probe that crashed or hung. */
 export function owesIsolated(record: QualificationRecord): boolean {
-  return PROBE_FAILED_HARD.has(record.probe.outcome) || record.verdicts.some((v) => v.measured && v.rating === "conditional");
+  return PROBE_FAILED_HARD.has(record.probe.outcome) || record.verdicts.some((v) => v.measured && (v.rating === "conditional" || memoryGapOnly(v)));
+}
+
+/**
+ * The pin a record can give back to a plugin whose state lost it: the bytes the probe pinned, and the word of a decided
+ * isolated step (`isolated` or `refused`). `undefined` when the record holds no whole pin or the step decided nothing.
+ */
+export function pinFromRecord(record: QualificationRecord): PinEntry | undefined {
+  const step = record.run?.steps.find((s) => s.step === RUN_STEP.isolated);
+  if (step === undefined || step.result === ISOLATED_RESULT.notRun) return undefined;
+  const { files, layout } = record.binary;
+  if (files === undefined || files.length === 0 || layout === undefined) return undefined;
+  const sorted = [...files].sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0));
+  const uri = record.plugin.format === "clap" ? clapPinUri(record.binary.path, record.plugin.id) : record.plugin.id;
+  return pinAfterStep({ uri, integrity: { files: sorted, layout } }, step);
 }
 
 /** Whether the isolated step saw this plugin running alone. A record's word alone never says so. */
@@ -180,7 +206,7 @@ export function pinAfterStep(pin: PinEntry | undefined, step: RunStep): PinEntry
 }
 
 /** The run id of a record from before the steps: its probe output's, read from the copy beside it. */
-function runIdOf(record: QualificationRecord, dir: string): string | undefined {
+export function runIdOf(record: QualificationRecord, dir: string): string | undefined {
   if (record.run !== undefined) return record.run.id;
   if (record.rejudged !== undefined) return record.rejudged.figures.runId;
   try {