@openmixer/plugin-qualify 0.20.0 → 0.20.3

package/src/lv2-loader.ts

@@ -64,27 +64,52 @@ function turtleTokens(ttl: string): Token[] {
   return out;
 }
 
+/**
+ * The path a file IRI names, as lilv and serd read it: a `file:` URI loses its scheme and authority, and the percent
+ * escapes of its path are decoded (`libSurge%20XT.so` is `libSurge XT.so` on the disk). A relative IRI is decoded the
+ * same way. A malformed escape leaves the text as written: the name is then looked up as it stands and not found, which
+ * is its own, named failure.
+ */
+export function iriPath(iri: string): string {
+  let path = iri;
+  const scheme = /^file:(?:\/\/[^/]*)?(?=\/)/i.exec(iri);
+  if (scheme !== null) path = iri.slice(scheme[0].length);
+  try {
+    return decodeURIComponent(path);
+  } catch {
+    return path;
+  }
+}
+
 /** A plugin a manifest declares, with the files it names for it, each relative to the bundle, in the order named. */
 export interface ManifestPlugin {
   readonly uri: string;
   readonly files: readonly string[];
-  /** The basename of its `lv2:binary`, when it names one. */
+  /** The basename of its `lv2:binary` as it is on the disk (the IRI's escapes decoded), when it names one. `files` keep the IRI's word, which is what a pin holds. */
   readonly binary?: string;
 }
 
+/** A statement of a Turtle text: the subject and predicate expanded, the object as written and, when it names one, expanded. */
+export interface TurtleTriple {
+  readonly subject: string;
+  readonly predicate: string;
+  /** The object's token: an `iri` is as written (a relative one stays relative), a `literal` carries no text. */
+  readonly object: { readonly kind: "iri" | "name" | "literal"; readonly text: string };
+  /** The object expanded: an absolute or relative IRI, or a prefixed name with a known prefix. */
+  readonly objectIri?: string;
+}
+
 /**
- * Every plugin a bundle manifest declares and the files it names for it with `lv2:binary` or `rdfs:seeAlso`: the
- * files plugin-hostd's pin holds besides `manifest.ttl` itself. A file named outside the bundle (an absolute IRI) is
- * not one of them.
+ * The statements of a Turtle text, as plugin-hostd reads a manifest to pin a plugin: statements of IRIs and prefixed
+ * names, with blank nodes and collections stepped over, not a whole Turtle parser. `lv2`, `rdfs` and `rdf` read even
+ * when a file leaves them undeclared.
  */
-export function manifestPlugins(ttl: string): ManifestPlugin[] {
-  // the three vocabularies every manifest uses, so a manifest that leaves a prefix undeclared still reads
+export function turtleTriples(ttl: string): TurtleTriple[] {
   const prefixes = new Map<string, string>([
     ["lv2", "http://lv2plug.in/ns/lv2core#"],
     ["rdfs", "http://www.w3.org/2000/01/rdf-schema#"],
     ["rdf", "http://www.w3.org/1999/02/22-rdf-syntax-ns#"],
   ]);
-  const subjects = new Map<string, { typed: boolean; files: string[]; binary?: string }>();
   const expand = (t: Token): string | undefined => {
     if (t.kind === "iri") return t.text;
     if (t.kind !== "name") return undefined;
@@ -93,6 +118,7 @@ export function manifestPlugins(ttl: string): ManifestPlugin[] {
     const base = colon < 0 ? undefined : prefixes.get(t.text.slice(0, colon));
     return base === undefined ? undefined : base + t.text.slice(colon + 1);
   };
+  const out: TurtleTriple[] = [];
   const tokens = turtleTokens(ttl);
   let state: "subject" | "predicate" | "object" | "after" = "subject";
   let depth = 0;
@@ -134,16 +160,29 @@ export function manifestPlugins(ttl: string): ManifestPlugin[] {
       state = "object";
     } else if (state === "object") {
       state = "after";
-      if (subject === undefined) continue;
-      const entry = subjects.get(subject) ?? { typed: false, files: [] };
-      subjects.set(subject, entry);
-      const object = expand(t);
-      if (predicate === RDF_TYPE && object === LV2_PLUGIN) entry.typed = true;
-      if ((predicate === LV2_BINARY || predicate === RDFS_SEE_ALSO) && t.kind === "iri" && !/^[A-Za-z][A-Za-z0-9+.-]*:/.test(t.text) && !t.text.startsWith("/")) {
-        const file = t.text.replace(/^(\.\/)+/, "");
-        if (!entry.files.includes(file)) entry.files.push(file);
-        if (predicate === LV2_BINARY && entry.binary === undefined) entry.binary = basename(file);
-      }
+      if (subject === undefined || predicate === undefined) continue;
+      const objectIri = expand(t);
+      out.push({ subject, predicate, object: { kind: t.kind as "iri" | "name" | "literal", text: t.text }, ...(objectIri === undefined ? {} : { objectIri }) });
+    }
+  }
+  return out;
+}
+
+/**
+ * Every plugin a bundle manifest declares and the files it names for it with `lv2:binary` or `rdfs:seeAlso`: the
+ * files plugin-hostd's pin holds besides `manifest.ttl` itself. A file named outside the bundle (an absolute IRI) is
+ * not one of them.
+ */
+export function manifestPlugins(ttl: string): ManifestPlugin[] {
+  const subjects = new Map<string, { typed: boolean; files: string[]; binary?: string }>();
+  for (const { subject, predicate, object, objectIri } of turtleTriples(ttl)) {
+    const entry = subjects.get(subject) ?? { typed: false, files: [] };
+    subjects.set(subject, entry);
+    if (predicate === RDF_TYPE && objectIri === LV2_PLUGIN) entry.typed = true;
+    if ((predicate === LV2_BINARY || predicate === RDFS_SEE_ALSO) && object.kind === "iri" && !/^[A-Za-z][A-Za-z0-9+.-]*:/.test(object.text) && !object.text.startsWith("/")) {
+      const file = object.text.replace(/^(\.\/)+/, "");
+      if (!entry.files.includes(file)) entry.files.push(file);
+      if (predicate === LV2_BINARY && entry.binary === undefined) entry.binary = basename(iriPath(file));
     }
   }
   return [...subjects.entries()]
@@ -151,6 +190,39 @@ export function manifestPlugins(ttl: string): ManifestPlugin[] {
     .map(([uri, e]) => ({ uri, files: e.files, ...(e.binary === undefined ? {} : { binary: e.binary }) }));
 }
 
+const PATCH_WRITABLE = "http://lv2plug.in/ns/ext/patch#writable";
+const RDFS_RANGE = "http://www.w3.org/2000/01/rdf-schema#range";
+const ATOM_PATH = "http://lv2plug.in/ns/ext/atom#Path";
+
+/**
+ * The content an LV2 plugin declares it plays from: the parameters it lists as `patch:writable` whose `rdfs:range` is
+ * `atom:Path` (a sampler's sample, a drum machine's kit), sorted. Read from the bundle on the search path whose
+ * manifest declares `uri`, in the manifest and every file it names for the plugin. Empty when the plugin declares none
+ * or no bundle on the path holds it (#318).
+ */
+export function lv2ContentParams(uri: string, env: Readonly<Record<string, string | undefined>>, home: string = homedir()): string[] {
+  for (const bundle of lv2BundlesOnPath(env, home)) {
+    let manifest: string;
+    try {
+      manifest = readFileSync(join(bundle, "manifest.ttl"), "utf8");
+    } catch {
+      continue;
+    }
+    const plugin = manifestPlugins(manifest).find((p) => p.uri === uri);
+    if (plugin === undefined) continue;
+    const triples = [manifest, ...plugin.files.filter((f) => f.endsWith(".ttl")).map((f) => {
+      try {
+        return readFileSync(join(bundle, f), "utf8");
+      } catch {
+        return "";
+      }
+    })].flatMap(turtleTriples);
+    const paths = new Set(triples.filter((t) => t.predicate === RDFS_RANGE && t.objectIri === ATOM_PATH).map((t) => t.subject));
+    return [...new Set(triples.filter((t) => t.subject === uri && t.predicate === PATCH_WRITABLE && t.objectIri !== undefined && paths.has(t.objectIri)).map((t) => t.objectIri!))].sort();
+  }
+  return [];
+}
+
 /** The plugins a bundle manifest declares, each with its `lv2:binary` basename. */
 export function pluginsInManifest(ttl: string): { uri: string; binary?: string }[] {
   return manifestPlugins(ttl).map((p) => (p.binary === undefined ? { uri: p.uri } : { uri: p.uri, binary: p.binary }));

package/src/measurement/cli.ts

@@ -35,7 +35,7 @@
 import { join } from "node:path";
 
 import type { MeasurementDocument, MeasurementRun, MeasuredPlugin } from "./format.js";
-import { buildMeasurementDocument } from "./format.js";
+import { buildMeasurementDocument, readIntegrity } from "./format.js";
 import { measuredPluginsFromProbeOutput } from "./probe-json.js";
 import { buildRun, costMethodFromProbeProvenance, hostFromProbeProvenance } from "./provenance.js";
 import type { MeasurementHost, LatencyMethod } from "./format.js";
@@ -237,10 +237,17 @@ export function buildPipeline(options: MeasureOptions, native?: HostingTools): P
     });
   }
 
+  // a run of the prober's dimensions alone takes the pin too: a plugin measured with no integrity block cannot be pinned
+  // from its figures (plugin-qualify#316), and the measurer names the files without instantiating anything
+  const pinned = !hosting && probed && native !== undefined && (options.plugins !== undefined || current !== undefined);
+  if (pinned && native !== undefined) {
+    steps.push({ id: "pin", command: native.tool, args: ["--pin"], perPlugin: true, produces: join(options.workDir, "pins.jsonl") });
+  }
+
   return {
     steps,
     ...(probed && current !== undefined ? { finalCatalog: current } : {}),
-    ...(hosting && options.plugins === undefined && current !== undefined ? { hostingScan: current } : {}),
+    ...((hosting || pinned) && options.plugins === undefined && current !== undefined ? { hostingScan: current } : {}),
     ...(costProvenance === undefined ? {} : { costProvenance }),
   };
 }
@@ -599,6 +606,8 @@ export interface AssemblyInput {
   readonly catalog?: unknown;
   /** The hosting pass's lines ({@link hostingLine}), one per plugin. Absent when it did not run. */
   readonly hosting?: readonly unknown[];
+  /** The measurer's `--pin` lines ({@link hostingLine}), one per plugin, for a run with no hosting pass. Absent when the pin step did not run. */
+  readonly pins?: readonly unknown[];
   /** The cost pass's provenance JSON, already parsed. Absent on a latency-only run. */
   readonly costProvenance?: unknown;
   /** Host facts, for a run whose provenance the cost pass did not write. */
@@ -636,6 +645,7 @@ export function assembleDocument(input: AssemblyInput): MeasurementDocument {
   const plugins: MeasuredPlugin[] =
     probed.length > 0 && input.catalog !== undefined ? measuredPluginsFromProbeOutput(input.catalog, probed) : [];
   if (input.hosting !== undefined) mergeHosting(plugins, measuredPluginsFromSweep({ measurements: input.hosting }), input.options.dimensions);
+  if (input.pins !== undefined) mergePins(plugins, input.pins);
   const costMethod = costMethodFromProbeProvenance(input.costProvenance);
   const host = hostFromProbeProvenance(input.costProvenance) ?? input.host;
   const run: MeasurementRun = buildRun({
@@ -655,6 +665,20 @@ export function assembleDocument(input: AssemblyInput): MeasurementDocument {
   return buildMeasurementDocument(run, plugins);
 }
 
+/** The pin lines folded into the prober's plugins, by URI: a plugin without one keeps none, and a line for a plugin not measured adds none. */
+function mergePins(plugins: MeasuredPlugin[], rows: readonly unknown[]): void {
+  for (const row of rows) {
+    if (typeof row !== "object" || row === null) continue;
+    const r = row as Record<string, unknown>;
+    const integrity = readIntegrity(r["integrity"]);
+    const at = plugins.findIndex((p) => p.uri === r["uri"]);
+    if (integrity === undefined || at < 0) continue;
+    const p = plugins[at]!;
+    const version = typeof r["version"] === "string" && r["version"] !== "" ? r["version"] : undefined;
+    plugins[at] = { ...p, ...(p.integrity === undefined ? { integrity } : {}), ...(p.version === undefined && version !== undefined ? { version } : {}) };
+  }
+}
+
 /**
  * The hosting pass's plugins folded into the prober's, by URI: each keeps the hosting dimensions the
  * run asked for and the pin, and a plugin only the hosting pass measured joins with its own topology.

package/src/measurement/format.ts

@@ -303,6 +303,8 @@ export interface MemoryFootprint {
   /** Activated, after processing: what a long-running host carries. */
   readonly atRestKb?: number;
   readonly notesHeldKb?: number;
+  /** The notes held (voices sounding) when `notesHeldKb` was read, the count `basis` says where it came from. */
+  readonly notesHeld?: number;
   readonly secondInstanceKb?: number;
   readonly basis?: VoiceBasis;
   readonly unmeasuredReason?: string;
@@ -950,6 +952,11 @@ function readLatency(value: unknown): LatencyMeasurement | undefined {
 }
 
 /** A KB figure: finite and never negative. */
+function notesCount(value: unknown): number | undefined {
+  const n = positiveNumber(value);
+  return n !== undefined && Number.isInteger(n) ? n : undefined;
+}
+
 function kilobytes(value: unknown): number | undefined {
   const n = finiteNumber(value);
   return n !== undefined && n >= 0 ? n : undefined;
@@ -963,6 +970,7 @@ export function readMemoryFootprint(value: unknown): MemoryFootprint | undefined
     ...optional("afterActivateKb", kilobytes(value.afterActivateKb)),
     ...optional("atRestKb", kilobytes(value.atRestKb)),
     ...optional("notesHeldKb", kilobytes(value.notesHeldKb)),
+    ...optional("notesHeld", notesCount(value.notesHeld)),
     ...optional("secondInstanceKb", kilobytes(value.secondInstanceKb)),
     ...optional("basis", isVoiceBasis(value.basis) ? value.basis : undefined),
     ...reasonOf(value),

package/src/measurement/vocabulary.ts

@@ -94,9 +94,9 @@ const UNMEASURED_DESCRIPTIONS: Readonly<Record<UnmeasuredCode, string>> = {
   "needs-impulse-response":
     "A convolver requiring an IR file the prober did not load.",
   "unpinnable":
-    "The files the host loads cannot be pinned (plugin-qualify spec §11.1): a path holding ',', '=' or " +
-      "whitespace, a manifest using @base or a percent-encoded IRI, or a CLAP plugin with more parameters than the " +
-      "host accepts. The plugin stays unpinned, never partly pinned.",
+    "The files the host loads cannot be pinned (plugin-qualify spec §11.1): a manifest using @base, a file name " +
+      "longer than a pin path, or a CLAP plugin with more parameters than the host accepts. A name with a space or a " +
+      "separator of pin_set is pinned percent-encoded. The plugin stays unpinned, never partly pinned.",
   "no-voices":
     "An instrument whose voice-info declares a voice capacity of 0: there is no voice to hold down, so its " +
       "cost with notes held cannot be taken.",

package/src/measurement-grid.ts

@@ -7,7 +7,7 @@
  *
  * Pure: no file, no process. `probe-runner.ts` runs what `runnerInvocations` plans.
  */
-import { GRID_CONTINUITY_QUANTUM } from "./qualify-declarations.js";
+import { COST_REFERENCE_RATE, GRID_CONTINUITY_QUANTUM, LONG_QUANTUM_FRAMES } from "./qualify-declarations.js";
 
 /** One cell of the grid. */
 export interface GridCell {
@@ -55,7 +55,7 @@ const byRateThenQuantum = (a: GridCell, b: GridCell): number => a.rate - b.rate
 
 /**
  * The cells of a grid, in the order they are taken: for `hosts`, each host's own cell in the order the hosts are given,
- * then `GRID_CONTINUITY_QUANTUM` at every rate; for `full`, those cells first as well, then the rest of the product by
+ * then `GRID_CONTINUITY_QUANTUM` at every rate, then the long quantum at the reference rate when the run measures that rate; for `full`, those cells first as well, then the rest of the product by
  * rate and quantum; for named cells, as named. A cell is listed once.
  */
 export function gridCells(
@@ -64,7 +64,9 @@ export function gridCells(
 ): GridCell[] {
   if (spec.kind === "cells") return unique(spec.cells);
   const continuity = [...context.rates].sort((a, b) => a - b).map((rate) => ({ rate, quantum: GRID_CONTINUITY_QUANTUM }));
-  const lead = unique([...context.hosts, ...continuity]);
+  // the console was judged at the long quantum until its basis moved to the reference one: that cell stays measured
+  const long = context.rates.includes(COST_REFERENCE_RATE) ? [{ rate: COST_REFERENCE_RATE, quantum: LONG_QUANTUM_FRAMES }] : [];
+  const lead = unique([...context.hosts, ...continuity, ...long]);
   if (spec.kind === "hosts") return lead;
   const product = context.rates.flatMap((rate) => context.quanta.map((quantum) => ({ rate, quantum }))).sort(byRateThenQuantum);
   const inProduct = new Set(product.map(cellKey));

package/src/pins-file.ts

@@ -127,8 +127,9 @@ export function pinClearLine(uri: string): string {
 
 /**
  * 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.
+ * holds a space. A file path is the prober's, percent-encoded as plugin-hostd-protocol writes a pin path (Surge XT's
+ * "Surge XT.clap" is Surge%20XT.clap), so it holds no whitespace, comma or equals sign; one that does was not encoded,
+ * and the plugin has no pin, refused by name.
  */
 export function pinLine(entry: PinEntry): string | undefined {
   const { files, layout } = entry.integrity;

package/src/probe-judge.ts

@@ -320,6 +320,11 @@ export function judgeProbeOutput(output: ProbeOutput, profiles: readonly HostPro
         };
       }
     }
+    // a run that admitted the plugin and says why its note test could not be observed (a sampler with nothing to play): shown,
+    // never deciding (#318)
+    if (ran && admission !== undefined && admission.admitted && admission.code !== undefined) {
+      reasons = [{ dimension: "hostAdmission", rating: "suitable", code: admission.code, params: admission.params }, ...reasons];
+    }
     const owed = facts.owed?.[profile.id];
     if (owed !== undefined) reasons = [owed, ...reasons];
     const rating = worstRating(reasons.map((r) => r.rating));

package/src/probe-output.ts

@@ -63,6 +63,14 @@ export interface ProbeCost {
   readonly warmupBlocks: number;
   /** For an instrument: the notes it held while it was timed, how many and why that many. */
   readonly voices?: VoicesHeld;
+  /** For an instrument: its cost at each count of notes held (probe output 1.4), in the cost's own unit. */
+  readonly voiceCurve?: readonly VoiceCurvePoint[];
+}
+
+export interface VoiceCurvePoint {
+  readonly held: number;
+  readonly median: number;
+  readonly percentile: { readonly p: number; readonly value: number };
 }
 
 export interface ProbeRtSafety {
@@ -255,15 +263,30 @@ function readCost(v: unknown, where: string): ProbeCost {
   if (median < 0 || value < 0) invalid(`${where} holds a negative cost`);
   const voices = o["voices"] === undefined ? undefined : readVoicesHeld(o["voices"]);
   if (o["voices"] !== undefined && voices === undefined) invalid(`${where} voices is not a count of held notes with its basis`);
+  const voiceCurve = o["voiceCurve"] === undefined ? undefined : readVoiceCurve(o["voiceCurve"], `${where} voiceCurve`);
   return {
     median,
     percentile: { p, value },
     blocks: posInt(o, "blocks", where),
     warmupBlocks: count(o, "warmupBlocks", where),
     ...(voices === undefined ? {} : { voices }),
+    ...(voiceCurve === undefined ? {} : { voiceCurve }),
   };
 }
 
+function readVoiceCurve(v: unknown, where: string): VoiceCurvePoint[] {
+  if (!Array.isArray(v)) invalid(`${where} is not a list`);
+  return (v as unknown[]).map((e, i) => {
+    const at = `${where} entry ${i}`;
+    const o = record(e, at);
+    const pct = record(o["percentile"], `${at} percentile`);
+    const median = num(o, "median", at);
+    const value = num(pct, "value", `${at} percentile`);
+    if (median < 0 || value < 0) invalid(`${at} holds a negative cost`);
+    return { held: posInt(o, "held", at), median, percentile: { p: num(pct, "p", `${at} percentile`), value } };
+  });
+}
+
 function readRtSafety(v: unknown, where: string): ProbeRtSafety {
   const o = record(v, where);
   const events = o["events"] === undefined ? undefined : (stringList(o["events"]) ?? invalid(`${where} events is not a list of strings`));

package/src/probe-runner.ts

@@ -12,7 +12,7 @@
  * unavailable, an output that could not be written), 3 is no such plugin.
  */
 import { spawnSync } from "node:child_process";
-import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
 import { availableParallelism, loadavg, tmpdir } from "node:os";
 import { join } from "node:path";
 
@@ -22,7 +22,7 @@ import type { HostProfile } from "./host-profiles.js";
 import { OPENMIXER_CONSOLE_PROFILE, shippedHostProfile } from "./host-profiles.js";
 import { IN_PROCESS_TIER_HOST, ISOLATED_TIER_HOST } from "./qualification-record.js";
 import type { PluginTarget } from "./loader.js";
-import { ADAPTER_RUN_HOSTS, SPAWNED_ADMISSIONS, admitPlugin, admitUnderAdapter, admittedHostOf, type AdmissionRuns, type HostAdmission } from "./host-admission.js";
+import { ADAPTER_RUN_HOSTS, SPAWNED_ADMISSIONS, noJackServerProblem, admitPlugin, admitUnderAdapter, admittedHostOf, type AdmissionRuns, type HostAdmission } from "./host-admission.js";
 import { judgeProbeOutput, judgmentVerdicts, type Judgment } from "./probe-judge.js";
 import { readProbeOutput, type ProbeOutput } from "./probe-output.js";
 import { budgetCells, gridCells, hostCells, runnerInvocations, type GridCell, type GridSpec, type RunnerInvocation } from "./measurement-grid.js";
@@ -30,6 +30,10 @@ import type { MemoryBound } from "./memory-bound.js";
 import { mergeProbeRuns, ProbeMergeError } from "./probe-merge.js";
 import type { QualifyVerdict } from "./qualify-cli.js";
 import {
+  MEMORY_PASS_PROBE_NOTES,
+  PROBE_NOTES_CURVE,
+  PROBE_NOTES_CURVE_ENV,
+  PROBE_NOTES_ENV,
   CLAP_QUALIFY_TIMEOUT_S,
   CLAP_SWEEP_BLOCKS,
   CLAP_SWEEP_FRAMES,
@@ -182,7 +186,11 @@ function runOne(target: PluginTarget, options: ProbeTargetOptions, invocation: R
   const log = join(work, "child.stderr.log");
   try {
     let args: string[];
-    let runEnv: Record<string, string | undefined> = { ...env };
+    // a HOME of the run's own, under its scratch directory: a plugin that reads its user data from HOME (Surge XT) dies
+    // or stays silent without one, and a probe must never write into the caller's real home
+    const home = join(work, "home");
+    mkdirSync(home);
+    let runEnv: Record<string, string | undefined> = { ...env, HOME: home };
     let expectedId: string;
     const wall = options.wallS === undefined ? {} : { wallS: options.wallS };
     const bound = options.memory === undefined ? {} : { dataBytes: options.memory.bytes };
@@ -196,7 +204,7 @@ function runOne(target: PluginTarget, options: ProbeTargetOptions, invocation: R
         target.binaryPath,
         expectedId,
       );
-      runEnv = { ...env, LD_PRELOAD: interposer };
+      runEnv = { ...runEnv, LD_PRELOAD: interposer, [PROBE_NOTES_CURVE_ENV]: env[PROBE_NOTES_CURVE_ENV] ?? PROBE_NOTES_CURVE.join(",") };
     } else {
       expectedId = target.uri;
       const child = locateNativeTool(LV2_MEASURE_TOOL_NAME, env, options.exists ?? existsSync).path;
@@ -204,6 +212,14 @@ function runOne(target: PluginTarget, options: ProbeTargetOptions, invocation: R
         { ...at, ...wall, out, log, ...(child === undefined ? {} : { child }) },
         target.uri,
       );
+      // an instrument that declares no voice capacity is played with this many notes held, so its cost and its memory
+      // under notes are measured, not left voices-unknown; a count the caller set wins
+      runEnv = {
+        ...runEnv,
+        [PROBE_NOTES_ENV]: env[PROBE_NOTES_ENV] ?? String(MEMORY_PASS_PROBE_NOTES),
+        // and timed at each count of the curve, the cost against the notes held
+        [PROBE_NOTES_CURVE_ENV]: env[PROBE_NOTES_CURVE_ENV] ?? PROBE_NOTES_CURVE.join(","),
+      };
     }
     // 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" };
@@ -322,12 +338,17 @@ export function qualifyTargets(
     const admissions: Record<string, HostAdmission> = {};
     // an LV2 plugin is also run once under plugin-hostd's LV2 adapter, recorded beside the verdicts (#223)
     const adapter = target.format === "lv2" ? admitUnderAdapter(target.uri, admissionRuns, admissionEnv) : undefined;
+    // no JACK server is the machine's, not the plugin's: the run stops by name instead of recording resp -201 in every record
+    const noJack = noJackServerProblem(adapter);
+    if (noJack !== undefined) throw new ProbeRunnerError(noJack);
     // and that run decides its omx-clap-host verdict, the isolated tier
     if (adapter !== undefined) for (const host of ADAPTER_RUN_HOSTS) admissions[host] = adapter;
     if (target.format === "lv2") {
       for (const profile of judgedProfiles) {
         const host = admittedHostOf(profile);
         if (host !== undefined) admissions[profile.id] = admitPlugin(host, target.uri, admissionRuns, admissionEnv);
+        const noJackHost = noJackServerProblem(admissions[profile.id]);
+        if (noJackHost !== undefined) throw new ProbeRunnerError(noJackHost);
       }
     }
     for (const profile of judgedProfiles) {

package/src/qualification-record.ts

@@ -20,11 +20,12 @@ import { join } from "node:path";
 
 import type { Adjustment } from "./history-adjust.js";
 import type { Judgment, RecordReason } from "./probe-judge.js";
-import { sha256Hex, PROBE_OK, type ProbeGridPoint, type ProbeOutput } from "./probe-output.js";
+import { sha256Hex, PROBE_NOT_ATTEMPTED, PROBE_OK, type ProbeGridPoint, type ProbeOutput } from "./probe-output.js";
 import type { VoicesHeld } from "./measurement/format.js";
 import { writeFileWhole } from "./whole-file.js";
 import { HOSTING_CODE } from "./hosting-codes.js";
 import { MEASUREMENT_UNMEASURED_REASONS } from "@openmixer/omx-contract";
+import { judgementRules, latencyMsOf, LATENCY_LINE_MS } from "./judgement-line.js";
 
 export const QUALIFICATION_RECORD_SCHEMA = "plugin-qualify.qualification-record/1";
 
@@ -201,6 +202,8 @@ export type RecordGridPoint = Omit<ProbeGridPoint, "latency" | "memory"> & {
   /** The footprint as measured, with what it comes to: what a client adding the plugin reads (`memory-budget.ts`). */
   readonly memory?: MemoryFootprint & { readonly firstInstanceKb?: number; readonly perInstanceKb?: number };
   readonly latency: (Omit<NonNullable<ProbeGridPoint["latency"]>, "measuredFrames"> & { readonly measuredFrames: number }) | UnmeasuredLatency;
+  /** The measured latency in milliseconds at the cell's rate, beside the record's `latencyLineMs`; absent when none was measured. */
+  readonly latencyMs?: number;
 };
 
 const UNMEASURED_WORDS: ReadonlySet<string> = new Set(Object.values(MEASUREMENT_UNMEASURED_REASONS).map((r) => r.word));
@@ -220,12 +223,20 @@ export function memoryOfCell(p: ProbeGridPoint): Pick<RecordGridPoint, "memory">
   return { memory: { ...p.memory, ...(first === undefined ? {} : { firstInstanceKb: first }), ...(per === undefined ? {} : { perInstanceKb: per }) } };
 }
 
+/** A grid point as the record writes it: its footprint, its latency or why there is none, and the latency in milliseconds. */
+export function gridPointOf(output: ProbeOutput, p: ProbeGridPoint): RecordGridPoint {
+  const latency = latencyOfCell(output, p);
+  const frames = (latency as { measuredFrames?: number }).measuredFrames;
+  return { ...p, ...memoryOfCell(p), latency, ...(frames === undefined ? {} : { latencyMs: latencyMsOf(frames, p.rate) }) };
+}
+
 /** The unmeasured word of a cell whose run did not end well, by its outcome code. */
 const OUTCOME_WORD: Readonly<Record<string, string>> = {
   "probe.crashed": word("probeCrashed"),
   "probe.timeout": word("probeTimeout"),
   "probe.refused-instantiation": word("refusedInstantiation"),
   "probe.non-finite-output": word("nonFiniteOutput"),
+  [PROBE_NOT_ATTEMPTED]: word("notAttempted"),
 };
 
 /**
@@ -361,6 +372,10 @@ export interface QualificationRecord {
   /** Who measured and when. */
   readonly tool: Readonly<Record<string, string>>;
   readonly measuredAt: string;
+  /** The latency line the cells' `latencyMs` stand against (`LATENCY_LINE_MS`); absent on a record written before it was declared. */
+  readonly latencyLineMs?: number;
+  /** The rules the verdicts were judged by (`judgementRules`); absent on a record written before they were stated. */
+  readonly rules?: string;
   /** The second verdict, per host class of the history that was read; absent until `adjust --history` has run. */
   readonly history?: readonly HistoryBlock[];
   /** Where the record came from when it was not measured on this device: the distributed set's provenance, as the set's package wrote it. */
@@ -419,7 +434,19 @@ export interface NotMeasured {
   readonly code: string;
 }
 
-const safe = (text: string): string => text.replace(/[^A-Za-z0-9._-]/g, "_");
+/**
+ * A name part as plugin-hostd-protocol's descriptor name rule writes it (PHD_DESCRIPTOR_SAFE_CHAR): each byte of the
+ * UTF-8 text outside [A-Za-z0-9._-] is one "_", as plugin-hostd's descriptors.c reads the name. "é" is two bytes: "__".
+ */
+export function descriptorNamePart(text: string): string {
+  let out = "";
+  for (const byte of Buffer.from(text, "utf8")) {
+    const c = String.fromCharCode(byte);
+    out += /[A-Za-z0-9._-]/.test(c) && byte < 0x80 ? c : "_";
+  }
+  return out;
+}
+const safe = descriptorNamePart;
 
 /** `<id>@<version>-<sha256 first 12>.<offer>`: one binary and one offer, whatever the run. */
 export function qualificationBaseName(output: ProbeOutput): string {
@@ -483,13 +510,15 @@ export function buildQualificationRecord(
     tiers: tiersOf(judgment),
     cost: judgment.hosts.map((h) => ({ host: h.verdict.host, ...h.cost })),
     measurements: {
-      grid: o.grid.map((p) => ({ ...p, ...memoryOfCell(p), latency: latencyOfCell(o, p) })),
+      grid: o.grid.map((p) => gridPointOf(o, p)),
       ...(o.behaviour === undefined ? {} : { behaviour: o.behaviour }),
       ...(unmeasuredFigures(o).length === 0 ? {} : { unmeasured: unmeasuredFigures(o) }),
     },
     ...(notMeasured.length === 0 ? {} : { notMeasured }),
     tool: o.run.tools,
     measuredAt: o.run.startedAt,
+    latencyLineMs: LATENCY_LINE_MS,
+    rules: judgementRules(),
     probe: {
       file: copy.file,
       sha256: copy.sha256,

package/src/qualify-adapter-pass.ts

@@ -22,7 +22,6 @@ import { HOSTD_ENV } from "./hostd-pin-files.js";
 import { freeDeadJackSlots } from "./jack-registry.js";
 import { cellKey, type GridCell } from "./measurement-grid.js";
 import { defaultAddressSpaceLimit } from "./direct-limit.js";
-import { PROBE_OK } from "./probe-output.js";
 import { QUALIFICATION_RECORD_SCHEMA, type AdapterBlock, type QualificationRecord } from "./qualification-record.js";
 import { ADMIT_ADDRESS_KB_ENV, ADMIT_STATE_DIR_ENV, ADMIT_STEP_MS_ENV, PI_CELLS } from "./qualify-declarations.js";
 import { digestFiles, type SyncContext, type SyncState } from "./qualify-sync.js";
@@ -90,7 +89,8 @@ const REAPING_JACKD = `trap 'kill -TERM $p 2>/dev/null' TERM; trap 'kill -KILL $
 
 /** `jackd` on a name of its own and the dummy driver, at the cell's rate and quantum; `undefined` when none came up. */
 export const startPrivateJack: JackStarter = (cell) => {
-  const name = `omx-qualify-${String(process.pid)}-${String(cell.quantum)}`;
+  // the rate is in the name: the cells of one pass run at the same quantum at two rates, on servers alive together
+  const name = `omx-qualify-${String(process.pid)}-${String(cell.rate)}-${String(cell.quantum)}`;
   // the rows of servers of ours that were killed, freed before this one asks for a row
   freeDeadJackSlots();
   let child: ChildProcess;
@@ -238,8 +238,7 @@ const readRecord = (path: string): QualificationRecord | undefined => {
 };
 
 /**
- * The run of each LV2 plugin of the state whose probe ended well (one that did not has no verdict a run could decide), at
- * each cell. Each record is written whole as its plugin ends.
+ * The run of each LV2 plugin of the state, whatever its probe ended with, at each cell. Each record is written whole as its plugin ends.
  */
 export function adapterPass(ctx: SyncContext, state: SyncState, options: AdapterPassOptions = {}): AdapterPassResult {
   const read = hostVersions(ctx.env, options.versions);
@@ -279,7 +278,9 @@ export function adapterPass(ctx: SyncContext, state: SyncState, options: Adapter
           count.failed++;
           continue;
         }
-        if (record.probe.outcome !== PROBE_OK) continue;
+        // a probe that crashed, hung or measured nothing is run too: the adapter's own process is not the probe's, and its
+        // answer replaces whatever the main run recorded there (a missing JACK server's no-jack-client), so no record keeps a
+        // stale code. The probe's outcome stays in the record beside it.
         if (options.force !== true && adapterFinished(record, versions)) {
           count.already++;
           continue;