@openmixer/plugin-qualify 0.20.1 → 0.20.4

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/plugin-db-cli.ts

@@ -0,0 +1,78 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Copyright (C) 2026 Pau Aliagas <linuxnow@gmail.com>
+/**
+ * plugin-db is the one writer's call into plugin-db's own store, as plugin-db's records documentation describes it:
+ * `plugin-db pin <address> --files <sha256> [--layout <scheme>:<sha256>]` writes the pinned layer, `plugin-db put
+ * <address> judged --writer plugin-qualify` writes the judged layer plugin-qualify is the one writer of, its body on
+ * stdin. `--system` names the service's store (plugin-db's own default otherwise, for an interactive caller). Nothing
+ * here computes a digest or a body; `plugin-db-pin.ts` and `judged-layer.ts` do.
+ */
+import { spawnSync } from "node:child_process";
+
+import type { JudgedBody } from "./judged-layer.js";
+import type { LayerPin } from "./judged-layer.js";
+
+/** The binary, else `plugin-db` on the PATH. */
+export const PLUGIN_DB_ENV = "PLUGIN_DB";
+
+export interface PluginDbRunResult {
+  readonly status: number | null;
+  readonly stdout: string;
+  readonly stderr: string;
+  /** plugin-db is not installed. */
+  readonly missing?: boolean;
+}
+
+/** One run of `plugin-db <args...>`, the body on stdin when one is given. */
+export type PluginDbRun = (args: readonly string[], input: string | undefined, env: Readonly<Record<string, string | undefined>>) => PluginDbRunResult;
+
+export const SPAWNED_PLUGIN_DB: PluginDbRun = (args, input, env) => {
+  const r = spawnSync(env[PLUGIN_DB_ENV] ?? "plugin-db", args, { encoding: "utf8", timeout: 30000, env: { ...env }, ...(input === undefined ? {} : { input }) });
+  const missing = (r.error as NodeJS.ErrnoException | undefined)?.code === "ENOENT";
+  return { status: r.status, stdout: r.stdout ?? "", stderr: r.stderr ?? "", ...(missing ? { missing } : {}) };
+};
+
+export interface PluginDbCallOptions {
+  /** The service's store (`--system`), plugin-db's own default otherwise. */
+  readonly system: boolean;
+}
+
+export type PluginDbCallResult = { readonly ok: true } | { readonly ok: false; readonly detail: string };
+
+function systemFlag(args: readonly string[], opts: PluginDbCallOptions): string[] {
+  return opts.system ? [...args, "--system"] : [...args];
+}
+
+function refusal(r: PluginDbRunResult, verb: string): PluginDbCallResult {
+  if (r.missing) return { ok: false, detail: `plugin-db is not installed: the store is plugin-db's to ${verb}` };
+  const detail = r.stderr.trim().split("\n").pop();
+  return { ok: false, detail: detail || `plugin-db ${verb} exited ${String(r.status)}` };
+}
+
+/** `plugin-db pin <address> --files <sha256> [--layout <scheme>:<sha256>]`: the files of a plugin's bytes, pinned. */
+export function pluginDbPin(
+  address: string,
+  pin: LayerPin,
+  opts: PluginDbCallOptions,
+  env: Readonly<Record<string, string | undefined>> = process.env,
+  run: PluginDbRun = SPAWNED_PLUGIN_DB,
+): PluginDbCallResult {
+  const args = systemFlag(["pin", address, "--files", pin.files, ...(pin.layout === null ? [] : ["--layout", pin.layout])], opts);
+  const r = run(args, undefined, env);
+  if (r.status !== 0 || r.missing) return refusal(r, "pin");
+  return { ok: true };
+}
+
+/** `plugin-db put <address> judged --writer plugin-qualify`, the judged layer's body on stdin. */
+export function pluginDbPutJudged(
+  address: string,
+  body: JudgedBody,
+  opts: PluginDbCallOptions,
+  env: Readonly<Record<string, string | undefined>> = process.env,
+  run: PluginDbRun = SPAWNED_PLUGIN_DB,
+): PluginDbCallResult {
+  const args = systemFlag(["put", address, "judged", "--writer", "plugin-qualify"], opts);
+  const r = run(args, JSON.stringify(body), env);
+  if (r.status !== 0 || r.missing) return refusal(r, "put");
+  return { ok: true };
+}

package/src/plugin-db-pin.ts

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Copyright (C) 2026 Pau Aliagas <linuxnow@gmail.com>
+/**
+ * The pin plugin-db holds for an address: `files`, the combined digest of every file a plugin's bytes are
+ * (`omx-files/1`, plugin-db's `plugin_db_tables.h`: the SHA-256 of the line `omx-files/1`, then one line
+ * `<path>\t<sha256>` per file in byte order of the paths, each ending in one `\n`), and `layout`, the parameter-layout
+ * fingerprint plugin-hostd's prober took (`omx-layout/1:<sha256>`), or none. Computed here from the raw per-file
+ * digests the prober wrote (`IntegrityMeasurement`): nothing here opens a file or hashes bytes plugin-hostd did not
+ * already hash.
+ */
+import { createHash } from "node:crypto";
+
+import type { IntegrityMeasurement, PinnedFile } from "./measurement/format.js";
+import type { LayerPin } from "./judged-layer.js";
+
+/** The scheme name the combined files digest states, plugin-db's `PDB_STORE_FILES_PIN_SCHEME`. */
+export const OMX_FILES_SCHEME = "omx-files/1";
+
+/** The combined `omx-files/1` digest of a pin's files, plugin-db's one way to fold several file hashes into one. */
+export function omxFilesDigest(files: readonly PinnedFile[]): string {
+  const sorted = [...files].sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0));
+  const text = [`${OMX_FILES_SCHEME}\n`, ...sorted.map((f) => `${f.path}\t${f.sha256}\n`)].join("");
+  return createHash("sha256").update(text).digest("hex");
+}
+
+/** The pin plugin-db holds for an integrity measurement, or `undefined` when it took no whole pin (no files). */
+export function layerPinOf(integrity: Pick<IntegrityMeasurement, "files" | "layout">): LayerPin | undefined {
+  if (integrity.files === undefined || integrity.files.length === 0) return undefined;
+  return {
+    files: omxFilesDigest(integrity.files),
+    layout: integrity.layout === undefined ? null : `${integrity.layout.scheme}:${integrity.layout.sha256}`,
+  };
+}

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;

package/src/qualify-declarations.ts

@@ -14,9 +14,16 @@ import { ORACLE_FLOOR_RATES, RT_HARD_TARGET } from "@openmixer/omx-contract";
 export const COST_REFERENCE_RATE = 96000;
 
 /**
- * The reference quantum in frames: the rig's buffer, and the block `benchmark.py` runs.
+ * The reference quantum in frames: the buffer the console aims at (96000/256), the quantum its budget is judged at,
+ * and the block `benchmark.py` runs.
  */
-export const QUANTUM_FRAMES = 1024;
+export const QUANTUM_FRAMES = 256;
+
+/**
+ * The long quantum, in frames: the console's basis until 0.20.2, kept as a measured cell so a plugin's cost at a large
+ * buffer stays on record beside its cost at the console's.
+ */
+export const LONG_QUANTUM_FRAMES = 1024;
 
 /** The rate the offline capture window is sized at; other rates scale from it. */
 export const MEASURE_BASE_RATE = 48000;
@@ -31,8 +38,8 @@ export const OPERATIONAL_RATE_FLOOR = 48000;
 /** The rates a run measures when `--rates` is not given — recorded in `run.rates`: omx-contract's ORACLE_FLOOR_RATES. */
 export const QUALIFY_RATES: readonly number[] = ORACLE_FLOOR_RATES;
 
-/** The quanta (frames) a run rates cost at when `--quanta` is not given: the contract's hard-target quantum, then 256, 512 and the reference. */
-export const QUALIFY_QUANTA: readonly number[] = [RT_HARD_TARGET.quantum, 256, 512, QUANTUM_FRAMES];
+/** The quanta (frames) a run rates cost at when `--quanta` is not given: the contract's hard-target quantum, the reference, 512 and the long quantum. */
+export const QUALIFY_QUANTA: readonly number[] = [RT_HARD_TARGET.quantum, QUANTUM_FRAMES, 512, LONG_QUANTUM_FRAMES];
 
 /** Seconds one plugin's offline pass may take before its worker is killed and it reads as a timeout. */
 export const PLUGIN_TIMEOUT_S = 15;
@@ -174,13 +181,22 @@ export const MEMORY_BOUND_EXIT_STATUS = 121;
 /**
  * The memory-only pass (`plugin-qualify-sync --memory-only`). With `PROBE_MEMORY_ONLY_ENV` set the probers take the
  * footprint and nothing else; the probe runner passes its environment on, so its limits hold unchanged.
- * `PROBE_NOTES_ENV` is the count of notes an instrument that declares no voice capacity holds, basis `probe`:
+ * `PROBE_NOTES_ENV` is the count of notes an instrument that declares no voice capacity holds, basis `probe`, in every
+ * LV2 run (probe-runner) and in the memory-only pass:
  * `MEMORY_PASS_PROBE_NOTES` unless `memory_notes` says otherwise.
  */
 export const PROBE_MEMORY_ONLY_ENV = "OMX_PROBE_MEMORY_ONLY";
 export const PROBE_NOTES_ENV = "OMX_PROBE_NOTES";
 export const MEMORY_PASS_PROBE_NOTES = 16;
 
+/**
+ * The counts of notes an LV2 instrument is timed at, besides its probe count, for its cost against the notes held
+ * (the rate's `voiceCurve`, probe output 1.4): the counts the Pi measurements held Surge XT at
+ * (openmixer.org/notes/instruments-on-a-pi-5), so a voice limit shows as the count past which the cost stops growing.
+ */
+export const PROBE_NOTES_CURVE_ENV = "OMX_PROBE_NOTES_CURVE";
+export const PROBE_NOTES_CURVE = [1, 8, 16, 32, 48, 64] as const;
+
 /**
  * What `tools/mod-host-admit.mjs` is told in an adapter-only pass: how long the host has for one command, its address
  * space (`ulimit -v`, in KB) and the directory for the state files of the plugin it loads.
@@ -239,6 +255,8 @@ export const DESCRIPTOR_CODE_SCHEMA_MISSING = "qualify.descriptor.schema-missing
 export const DESCRIPTOR_CODE_SCHEMA_FLOOR = "qualify.descriptor.schema-floor";
 export const DESCRIPTOR_CODE_BINARY_UNHASHED = "qualify.descriptor.binary-unhashed";
 export const DESCRIPTOR_CODE_DIR_UNWRITABLE = "qualify.descriptor.dir-unwritable";
+/** Two ports of one plugin carry the same symbol: neither can be addressed by it, so the plugin is not described. Args: `symbol`. */
+export const DESCRIPTOR_CODE_DUPLICATE_SYMBOL = "qualify.descriptor.duplicate-symbol";
 
 
 
@@ -317,11 +335,14 @@ const piMemory = (ramGib: number): NonNullable<HostBudget["memory"]> => ({
 /**
  * The cells a Raspberry Pi runs: zynthian-sys's JACK settings, 48000/128 on a Pi 5 with the V5 kit and 48000/256 on a Pi 4 and
  * the other kits, the one a Pi 5 with no kit card also ran its stress and first boot at. The Zynthian benchmark's matrix sweeps
- * more cells; these two are what a Pi is set to.
+ * more cells; these two are what a Pi is set to. Every Pi matrix carries 96000 beside 48000, so each of the two quanta
+ * is also run at twice the base rate: the passes that follow these cells (adapter, isolated, memory, pool) cost twice as long.
  */
 export const PI_CELLS = [
   { rate: MEASURE_BASE_RATE, quantum: 128 },
   { rate: MEASURE_BASE_RATE, quantum: 256 },
+  { rate: 2 * MEASURE_BASE_RATE, quantum: 128 },
+  { rate: 2 * MEASURE_BASE_RATE, quantum: 256 },
 ];
 
 export const HOST_BUDGETS = {