@openmixer/plugin-qualify 0.20.1 → 0.20.3

package/src/host-admission.ts

@@ -11,6 +11,7 @@
 import { spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
 
+import { withRunHome } from "./run-home.js";
 import type { HostProfile } from "./host-profiles.js";
 import { ADMIT_STEP_MS_ENV } from "./qualify-declarations.js";
 
@@ -83,7 +84,17 @@ export interface ModHostRun {
    * not be read. Absent for a plugin that is no instrument, and for any plugin under mod-host.
    */
   /** `notes`: how many keys were played; a run from when one key was played has none. */
-  readonly sound?: { readonly peak?: number; readonly notes?: number; readonly problem?: string };
+  readonly sound?: { readonly peak?: number; readonly notes?: number; readonly problem?: string; readonly content?: AdapterContent };
+}
+
+/**
+ * The content an instrument declares it plays from (its `patch:writable` parameters of range `atom:Path`, `lv2ContentParams`)
+ * and what came of giving each a short sample before the notes: `loaded` the host took, `refused` it did not (with its answer).
+ */
+export interface AdapterContent {
+  readonly params: readonly string[];
+  readonly loaded: readonly string[];
+  readonly refused?: readonly string[];
 }
 
 /** At or under this magnitude (-120 dBFS) a held note is taken as digital silence: clap-qualify's own SILENCE. */
@@ -97,6 +108,22 @@ export const SILENT_PEAK = 1e-6;
 export const ADAPTER_SILENT_CODE = `${ADAPTER_HOST}.silent-under-note`;
 export const ADAPTER_LEVEL_UNMEASURED_CODE = `${ADAPTER_HOST}.level-unmeasured`;
 const UNPROVEN_SOUND: readonly string[] = [ADAPTER_SILENT_CODE, ADAPTER_LEVEL_UNMEASURED_CODE];
+/**
+ * An instrument that declares content it plays from and stayed silent under the notes even so: the content could not be
+ * given (the host refused the sample) or the sample did not reach the keys played. Its silence says nothing of the plugin,
+ * so the note test is not observable for it: the run admits it, and the record names this code and the content (#318).
+ * No other host is asked instead.
+ */
+export const ADAPTER_CONTENT_UNOBSERVED_CODE = `${ADAPTER_HOST}.silent-needs-content`;
+
+/** The run's content, as a reason's params carry it: the declared parameters, the ones loaded, the ones refused. */
+function contentParams(content: AdapterContent): Record<string, string> {
+  return {
+    content: content.params.join(" "),
+    loaded: content.loaded.join(" "),
+    ...(content.refused === undefined || content.refused.length === 0 ? {} : { refused: content.refused.join("; ") }),
+  };
+}
 
 /** The rating a run that did not admit the plugin gives its host's verdict. */
 export function admissionRating(admission: HostAdmission): "unsuitable" | "unknown" {
@@ -109,6 +136,19 @@ export function admissionRating(admission: HostAdmission): "unsuitable" | "unkno
  */
 const JACK_CLIENT_RESPS: readonly number[] = [-201, -202];
 
+/** The name of the reason a run stops on when no JACK server answers: the admission cannot say anything of any plugin. */
+export const NO_JACK_SERVER = "no JACK server";
+
+/**
+ * The refusal to go on when an admission found no JACK client to have (`<host>.no-jack-client`): the server the host is
+ * pointed at (the default one, or `JACK_DEFAULT_SERVER`) is not there, and every plugin would be recorded with the same
+ * resp -201 as if it were the plugin's. `undefined` for any other run.
+ */
+export function noJackServerProblem(admission: HostAdmission | undefined): string | undefined {
+  if (admission === undefined || admission.measured || !admission.code?.endsWith(".no-jack-client")) return undefined;
+  return `${NO_JACK_SERVER}: ${admission.host} could not open a JACK client (resp ${String(admission.params["resp"] ?? "-201")}), so nothing is learned of any plugin; start the JACK server it is pointed at (JACK_DEFAULT_SERVER names it) and run again`;
+}
+
 /** 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);
@@ -128,7 +168,14 @@ export function classifyProtocolRun(host: ProtocolHost, run: ModHostRun): HostAd
   if (run.sound !== undefined) {
     const { peak, problem } = run.sound;
     if (peak === undefined) return { host, measured: true, admitted: false, code: ADAPTER_LEVEL_UNMEASURED_CODE, params: { problem: problem ?? "no figure" } };
-    if (!(peak > SILENT_PEAK)) return { host, measured: true, admitted: false, code: ADAPTER_SILENT_CODE, params: { peak, ...(run.sound.notes === undefined ? {} : { notes: run.sound.notes }) } };
+    const notes: Record<string, number> = run.sound.notes === undefined ? {} : { notes: run.sound.notes };
+    const content = run.sound.content;
+    if (!(peak > SILENT_PEAK)) {
+      if (content !== undefined && content.params.length > 0) return { host, measured: true, admitted: true, code: ADAPTER_CONTENT_UNOBSERVED_CODE, params: { peak, ...notes, ...contentParams(content) } };
+      return { host, measured: true, admitted: false, code: ADAPTER_SILENT_CODE, params: { peak, ...notes } };
+    }
+    // it sounded on the content it was given: the record says which
+    if (content !== undefined && content.loaded.length > 0) return { ...admitted(host), params: { peak, ...notes, ...contentParams(content) } };
   }
   return admitted(host);
 }
@@ -186,14 +233,14 @@ export const SPAWNED_ADMISSIONS: AdmissionRuns = {
     // two commands at the limit the pass gives each, and the tool's own start and end: it kills the host itself first
     const stepMs = Number(env?.[ADMIT_STEP_MS_ENV] ?? 0);
     const timeout = stepMs > 0 ? 2 * stepMs + 15000 : MOD_HOST_ADMISSION_MS;
-    const r = spawnSync(process.execPath, [MOD_HOST_ADMIT, uri, ADAPTER_HOST], { encoding: "utf8", timeout, killSignal: "SIGKILL", ...(env === undefined ? {} : { env: { ...env } }) });
+    const r = spawnSync(process.execPath, [MOD_HOST_ADMIT, uri, ADAPTER_HOST], { encoding: "utf8", timeout, killSignal: "SIGKILL", env: withRunHome(env ?? process.env) });
     if (r.error !== undefined || r.status !== 0) {
       throw new Error(`${ADAPTER_HOST} admission of ${uri} gave no answer (${r.error?.message ?? `exit ${String(r.status)}`}): ${(r.stderr ?? "").trim()}`);
     }
     return JSON.parse(r.stdout) as ModHostRun;
   },
   modHost(uri, env) {
-    const r = spawnSync(process.execPath, [MOD_HOST_ADMIT, uri], { encoding: "utf8", timeout: MOD_HOST_ADMISSION_MS, ...(env === undefined ? {} : { env: { ...env } }) });
+    const r = spawnSync(process.execPath, [MOD_HOST_ADMIT, uri], { encoding: "utf8", timeout: MOD_HOST_ADMISSION_MS, env: withRunHome(env ?? process.env) });
     if (r.error !== undefined || r.status !== 0) {
       throw new Error(`mod-host admission of ${uri} gave no answer (${r.error?.message ?? `exit ${String(r.status)}`}): ${(r.stderr ?? "").trim()}`);
     }
@@ -203,7 +250,7 @@ export const SPAWNED_ADMISSIONS: AdmissionRuns = {
     // SIGKILL at the deadline: jalv hosting some plugins ignores SIGTERM, and one stuck in jack_client_open never reaches
     // the loop that reads the flag TERM sets, so a TERM left spawnSync waiting with it (#187). Alive at the deadline is
     // all the verdict asks, so nothing is lost by not letting it exit cleanly.
-    const r = spawnSync("jalv", ["-n", "plugin-qualify", uri], { encoding: "utf8", timeout: JALV_HOSTED_MS, killSignal: "SIGKILL", input: "", ...(env === undefined ? {} : { env: { ...env } }) });
+    const r = spawnSync("jalv", ["-n", "plugin-qualify", uri], { encoding: "utf8", timeout: JALV_HOSTED_MS, killSignal: "SIGKILL", input: "", env: withRunHome(env ?? process.env) });
     const code = (r.error as NodeJS.ErrnoException | undefined)?.code;
     if (code === "ENOENT") return { installed: false, stillRunning: false, status: null, signal: null, stderr: "" };
     return { installed: true, stillRunning: code === "ETIMEDOUT", status: r.status, signal: code === "ETIMEDOUT" ? null : r.signal, stderr: r.stderr ?? "" };

package/src/hostd-search-path.ts

@@ -0,0 +1,85 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Copyright (C) 2026 Pau Aliagas <linuxnow@gmail.com>
+/**
+ * The directories the sync scans, as plugin-hostd searches them (plugin-qualify#9). One definition of the search path:
+ * the daemon's, which `plugin-hostd --search-path [-c <file>]` prints from the code it searches with (plugin-hostd 0.20.3
+ * and later). This module never works the lists out itself: it runs the daemon on its settings file and reads the
+ * `lv2` and `clap` lines, and where each list came from (`file`, `env` or `default`).
+ */
+import { spawnSync } from "node:child_process";
+import { HOSTD_ENV } from "./hostd-pin-files.js";
+
+/** Where plugin-hostd took a list from: its settings file, its environment (`LV2_PATH`, `CLAP_PATH`) or its default. */
+export type SearchPathSource = "file" | "env" | "default";
+
+export interface HostdSearchPath {
+  /** The LV2 directories, in the order the daemon searches them: `lv2_path` then `lv2_extra`. */
+  readonly lv2: readonly string[];
+  /** The CLAP directories, in the order the daemon searches them. */
+  readonly clap: readonly string[];
+  /** Where each of `lv2_path`, `lv2_extra` and `clap_path` came from. */
+  readonly sources: Readonly<Record<"lv2_path" | "lv2_extra" | "clap_path", SearchPathSource>>;
+}
+
+export interface SearchPathRunResult {
+  readonly status: number | null;
+  readonly stdout: string;
+  readonly stderr: string;
+  /** The daemon is not installed. */
+  readonly missing?: boolean;
+}
+
+/** One run of `plugin-hostd --search-path`, with `-c <conf>` when a settings file is named. */
+export type SearchPathRun = (conf: string | undefined, env: Readonly<Record<string, string | undefined>>) => SearchPathRunResult;
+
+export const SPAWNED_SEARCH_PATH: SearchPathRun = (conf, env) => {
+  const r = spawnSync(env[HOSTD_ENV] ?? "plugin-hostd", [...(conf === undefined ? [] : ["-c", conf]), "--search-path"], { encoding: "utf8", timeout: 30000, env: { ...env } });
+  const missing = (r.error as NodeJS.ErrnoException | undefined)?.code === "ENOENT";
+  return { status: r.status, stdout: r.stdout ?? "", stderr: r.stderr ?? "", ...(missing ? { missing } : {}) };
+};
+
+const SOURCES: readonly string[] = ["file", "env", "default"];
+const dirList = (text: string): string[] => text.split(":").filter((d) => d !== "");
+
+/** The lines `plugin-hostd --search-path` prints, read: `<key> TAB <source> TAB <value>`; why not, when one is missing. */
+export function parseSearchPath(stdout: string): { ok: true; path: HostdSearchPath } | { ok: false; error: string } {
+  const rows = new Map<string, { source: string; value: string }>();
+  for (const line of stdout.split("\n")) {
+    const f = line.split("\t");
+    if (f.length >= 2 && f[0] !== undefined && f[1] !== undefined) rows.set(f[0], { source: f[1], value: f.slice(2).join("\t") });
+  }
+  for (const key of ["lv2_path", "lv2_extra", "clap_path"]) {
+    const r = rows.get(key);
+    if (r === undefined || !SOURCES.includes(r.source)) return { ok: false, error: `plugin-hostd --search-path printed no ${key} with its source` };
+  }
+  const lv2 = rows.get("lv2");
+  const clap = rows.get("clap");
+  if (lv2?.source !== "effective" || clap?.source !== "effective") return { ok: false, error: "plugin-hostd --search-path printed no effective lv2 and clap lists" };
+  const src = (key: string) => rows.get(key)!.source as SearchPathSource;
+  return { ok: true, path: { lv2: dirList(lv2.value), clap: dirList(clap.value), sources: { lv2_path: src("lv2_path"), lv2_extra: src("lv2_extra"), clap_path: src("clap_path") } } };
+}
+
+/** The directories plugin-hostd searches with the settings file `conf` (its own default when undefined); why not, when it cannot say. */
+export function hostdSearchPath(
+  conf: string | undefined,
+  env: Readonly<Record<string, string | undefined>> = process.env,
+  run: SearchPathRun = SPAWNED_SEARCH_PATH,
+): { ok: true; path: HostdSearchPath } | { ok: false; error: string } {
+  const r = run(conf, env);
+  if (r.missing) return { ok: false, error: "plugin-hostd is not installed: the directories scanned are the ones plugin-hostd searches" };
+  if (r.status !== 0) {
+    const why = /unrecognized option|^Usage:/m.test(r.stdout + r.stderr)
+      ? "this plugin-hostd has no --search-path (plugin-hostd 0.20.3 or later names the directories it searches)"
+      : r.stderr.trim().split("\n").pop() || `plugin-hostd --search-path exited ${String(r.status)}`;
+    return { ok: false, error: why };
+  }
+  return parseSearchPath(r.stdout);
+}
+
+/** What the run says when a list is not the settings file's: the running daemon, started with another environment, may search other directories. */
+export function searchPathWarnings(path: HostdSearchPath, conf: string | undefined): string[] {
+  const where = conf ?? "plugin-hostd's own settings file";
+  return (["lv2_path", "clap_path"] as const)
+    .filter((k) => path.sources[k] !== "file")
+    .map((k) => `${k} is plugin-hostd's ${path.sources[k] === "env" ? `environment (${k === "lv2_path" ? "LV2_PATH" : "CLAP_PATH"})` : "default"}, not ${where}: the running daemon may search other directories; write ${k} in ${where}`);
+}

package/src/jack-registry.ts

@@ -3,7 +3,7 @@
 /**
  * JACK's table of its servers, /dev/shm/jack-shm-registry: a header, then eight rows of a pid and a name
  * (`jack-<uid>:<server>:`). A server that is killed never clears its row, and once the eight are taken no server starts.
- * The adapter pass starts and stops servers of its own, `omx-qualify-<pid>-<quantum>`; a row of one of those whose
+ * The adapter pass starts and stops servers of its own, `omx-qualify-<pid>-<rate>-<quantum>`; a row of one of those whose
  * process is gone is freed (pid 0, name empty) before the next start, as jackd frees its own row when it ends well.
  * Rows of any other server are never touched, and a file of another layout is left as it is.
  */

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/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

@@ -434,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 {

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;