@openmixer/plugin-qualify 0.14.1 → 0.16.0

package/src/host-admission.ts

@@ -0,0 +1,136 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Copyright (C) 2026 Pau Aliagas <linuxnow@gmail.com>
+/**
+ * HOST ADMISSION — a `mod-host` or `jalv` verdict is MEASURED by running the plugin under that host,
+ * one admission per plugin, not judged from a declaration. mod-host: `add`, `remove` on
+ * its socket, a fresh host after any death (`tools/mod-host-admit.mjs` does the run and prints what
+ * happened; one line of JSON). jalv: `jalv -n <name> <uri>` headless, hosted when it is still alive
+ * at the deadline. The classifiers here are pure: what the host answered goes in, a {@link HostAdmission}
+ * with the deciding code comes out; the runs are injected, so a test replays recorded answers.
+ */
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+
+import type { HostProfile } from "./host-profiles.js";
+
+/** The profile ids whose verdict is measured by a run. */
+export const ADMITTED_HOSTS = ["mod-host", "jalv"] as const;
+export type AdmittedHost = (typeof ADMITTED_HOSTS)[number];
+
+/** The admitting host of a profile, or `undefined` when its verdict is judged from a declaration. */
+export function admittedHostOf(profile: HostProfile): AdmittedHost | undefined {
+  return ADMITTED_HOSTS.find((h) => h === profile.id);
+}
+
+/** What running the plugin under one host came to. */
+export interface HostAdmission {
+  readonly host: AdmittedHost;
+  /** False when the host could not be run (not installed): there is no evidence either way. */
+  readonly measured: boolean;
+  readonly admitted: boolean;
+  /** Why not: `<host>.resp-<n>`, `<host>.signal-<SIG>`, `mod-host.died-on-add`, `jalv.unknown-port-type`, `<host>.not-installed`, … */
+  readonly code?: string;
+  readonly params: Readonly<Record<string, string | number>>;
+}
+
+const admitted = (host: AdmittedHost): HostAdmission => ({ host, measured: true, admitted: true, params: {} });
+const refused = (host: AdmittedHost, code: string, params: HostAdmission["params"] = {}): HostAdmission => ({
+  host,
+  measured: true,
+  admitted: false,
+  code: `${host}.${code}`,
+  params,
+});
+const notInstalled = (host: AdmittedHost): HostAdmission => ({ host, measured: false, admitted: false, code: `${host}.not-installed`, params: {} });
+
+/** One command mod-host was sent and what came of it: its `resp` number, or how the host died. */
+export interface ModHostStep {
+  readonly cmd: "add" | "remove";
+  readonly resp?: number;
+  /** The signal that killed the host, or `exit` / `closed` when it went without one. */
+  readonly died?: string;
+}
+
+/** What `tools/mod-host-admit.mjs` printed. */
+export interface ModHostRun {
+  readonly installed: boolean;
+  readonly steps: readonly ModHostStep[];
+}
+
+/** The verdict of a mod-host run: the first step that did not answer `resp 0` decides. */
+export function classifyModHostRun(run: ModHostRun): HostAdmission {
+  if (!run.installed) return notInstalled("mod-host");
+  for (const s of run.steps) {
+    if (s.died !== undefined) {
+      if (s.died.startsWith("SIG")) return refused("mod-host", `signal-${s.died}`, { step: s.cmd });
+      return s.cmd === "add" ? refused("mod-host", "died-on-add", { how: s.died }) : refused("mod-host", "died", { step: s.cmd, how: s.died });
+    }
+    if (s.resp === undefined) return refused("mod-host", "no-answer", { step: s.cmd });
+    // mod-host answers an error as a negative number (`resp -102`); the code carries its magnitude
+    if (s.resp < 0) return refused("mod-host", `resp-${-s.resp}`, { step: s.cmd, resp: s.resp });
+  }
+  if (run.steps.length === 0) return refused("mod-host", "no-answer");
+  return admitted("mod-host");
+}
+
+/** What `jalv -n <name> <uri>` did in its window. */
+export interface JalvRun {
+  readonly installed: boolean;
+  /** True when jalv was still running at the deadline and was stopped by the caller. */
+  readonly stillRunning: boolean;
+  readonly status: number | null;
+  readonly signal: string | null;
+  readonly stderr: string;
+}
+
+const UNKNOWN_PORT_TYPE = /Mandatory port "([^"]*)" has unknown type/;
+
+/** The verdict of a jalv run: alive at the deadline is hosted; a signal, an unknown port type, or an exit is not. */
+export function classifyJalvRun(run: JalvRun): HostAdmission {
+  if (!run.installed) return notInstalled("jalv");
+  if (run.stillRunning) return admitted("jalv");
+  if (run.signal !== null) return refused("jalv", `signal-${run.signal}`);
+  const port = UNKNOWN_PORT_TYPE.exec(run.stderr)?.[1];
+  if (port !== undefined) return refused("jalv", "unknown-port-type", { port });
+  if (run.status !== 0 && run.status !== null) return refused("jalv", `exit-${run.status}`);
+  return admitted("jalv");
+}
+
+/** How long jalv must stay alive to count as hosting the plugin, in milliseconds. */
+export const JALV_HOSTED_MS = 3000;
+/** The wall clock of one whole mod-host admission, in milliseconds. */
+export const MOD_HOST_ADMISSION_MS = 30000;
+
+export interface AdmissionRuns {
+  readonly modHost: (uri: string) => ModHostRun;
+  readonly jalv: (uri: string) => JalvRun;
+}
+
+const MOD_HOST_ADMIT = fileURLToPath(new URL("../tools/mod-host-admit.mjs", import.meta.url));
+
+/** The runs against the installed hosts. */
+export const SPAWNED_ADMISSIONS: AdmissionRuns = {
+  modHost(uri) {
+    const r = spawnSync(process.execPath, [MOD_HOST_ADMIT, uri], { encoding: "utf8", timeout: MOD_HOST_ADMISSION_MS });
+    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()}`);
+    }
+    return JSON.parse(r.stdout) as ModHostRun;
+  },
+  jalv(uri) {
+    const r = spawnSync("jalv", ["-n", "plugin-qualify", uri], { encoding: "utf8", timeout: JALV_HOSTED_MS, input: "" });
+    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 ?? "" };
+  },
+};
+
+/** One admission of `uri` under `host`. */
+export function admitPlugin(host: AdmittedHost, uri: string, runs: AdmissionRuns = SPAWNED_ADMISSIONS): HostAdmission {
+  try {
+    return host === "mod-host" ? classifyModHostRun(runs.modHost(uri)) : classifyJalvRun(runs.jalv(uri));
+  } catch (e) {
+    // the run itself broke: nothing was learned about the plugin, so nothing is rated
+    return { host, measured: false, admitted: false, code: `${host}.admission-failed`, params: { problem: e instanceof Error ? e.message : String(e) } };
+  }
+}

package/src/index.ts

@@ -25,3 +25,9 @@ export * from "./probe-judge.js";
 export * from "./qualification-record.js";
 export * from "./probe-runner.js";
 export * from "./judge-cli.js";
+export * from "./whole-file.js";
+export * from "./qualify-sync.js";
+export * from "./host-admission.js";
+export * from "./history-file.js";
+export * from "./history-adjust.js";
+export * from "./adjust-cli.js";

package/src/lv2-loader.ts

@@ -6,8 +6,9 @@
  * plugin, with its `lv2:binary` basename. Anything else shaped like a URI (`scheme:rest`) is one
  * plugin. A path that does not exist is not this loader's — the CLI refuses it by name.
  *
- * The manifest read is the subset every LV2 bundle's manifest uses (subject, `a lv2:Plugin`,
- * `lv2:binary <x.so>`), not a Turtle parser; `--all` goes through lilv itself.
+ * The manifest is read as plugin-hostd reads it to pin a plugin: statements of IRIs and prefixed names, with blank
+ * nodes and collections stepped over, not a whole Turtle parser. A plugin is a subject typed `lv2:Plugin`; its files
+ * are the ones the manifest names for it with `lv2:binary` or `rdfs:seeAlso`.
  */
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { homedir } from "node:os";
@@ -17,21 +18,144 @@ import type { PluginLoader, PluginTarget } from "./loader.js";
 
 const URI_SHAPE = /^[A-Za-z][A-Za-z0-9+.-]*:\S+$/;
 
-/** The plugins a bundle manifest declares: one statement per subject, `;`-separated predicates. */
-export function pluginsInManifest(ttl: string): { uri: string; binary?: string }[] {
-  const body = ttl.replace(/#[^\n>]*$/gm, "");
-  const out: { uri: string; binary?: string }[] = [];
-  const statement = /<([^>]+)>\s+((?:[^.<"]|<[^>]*>|"[^"]*")*)\./g;
-  for (let m = statement.exec(body); m !== null; m = statement.exec(body)) {
-    const [, subject, predicates] = m;
-    if (subject === undefined || predicates === undefined) continue;
-    if (!/(^|;)\s*a\s+lv2:Plugin\b/.test(predicates)) continue;
-    const bin = /lv2:binary\s+<([^>]+)>/.exec(predicates)?.[1];
-    out.push(bin === undefined ? { uri: subject } : { uri: subject, binary: basename(bin) });
+const RDF_TYPE = "http://www.w3.org/1999/02/22-rdf-syntax-ns#type";
+const LV2_PLUGIN = "http://lv2plug.in/ns/lv2core#Plugin";
+const LV2_BINARY = "http://lv2plug.in/ns/lv2core#binary";
+const RDFS_SEE_ALSO = "http://www.w3.org/2000/01/rdf-schema#seeAlso";
+
+type Token = { readonly kind: "iri" | "name" | "punct" | "literal"; readonly text: string };
+
+/** The words of a Turtle text: IRIs, prefixed names, literals (with their tag or type) and punctuation; comments dropped. */
+function turtleTokens(ttl: string): Token[] {
+  const out: Token[] = [];
+  let i = 0;
+  while (i < ttl.length) {
+    const c = ttl[i]!;
+    if (/\s/.test(c)) i++;
+    else if (c === "#") while (i < ttl.length && ttl[i] !== "\n") i++;
+    else if (c === "<") {
+      const end = ttl.indexOf(">", i);
+      if (end < 0) break;
+      out.push({ kind: "iri", text: ttl.slice(i + 1, end) });
+      i = end + 1;
+    } else if (c === '"' || c === "'") {
+      const quote = ttl.startsWith(c.repeat(3), i) ? c.repeat(3) : c;
+      let j = i + quote.length;
+      while (j < ttl.length && !ttl.startsWith(quote, j)) j += ttl[j] === "\\" ? 2 : 1;
+      i = j + quote.length;
+      // a language tag or a datatype belongs to the literal
+      if (ttl[i] === "@") while (i < ttl.length && /[A-Za-z0-9-@]/.test(ttl[i]!)) i++;
+      else if (ttl.startsWith("^^", i)) {
+        i += 2;
+        if (ttl[i] === "<") i = ttl.indexOf(">", i) + 1;
+        else while (i < ttl.length && /[^\s;,.\])]/.test(ttl[i]!)) i++;
+      }
+      out.push({ kind: "literal", text: "" });
+    } else if (".;,[]()".includes(c)) {
+      out.push({ kind: "punct", text: c });
+      i++;
+    } else {
+      let j = i;
+      while (j < ttl.length && /[^\s<>"';,\[\]()]/.test(ttl[j]!) && !(ttl[j] === "." && (j + 1 >= ttl.length || /\s/.test(ttl[j + 1]!)))) j++;
+      out.push({ kind: "name", text: ttl.slice(i, j) });
+      i = Math.max(j, i + 1);
+    }
   }
   return out;
 }
 
+/** 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. */
+  readonly binary?: 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.
+ */
+export function manifestPlugins(ttl: string): ManifestPlugin[] {
+  // the three vocabularies every manifest uses, so a manifest that leaves a prefix undeclared still reads
+  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;
+    if (t.text === "a") return RDF_TYPE;
+    const colon = t.text.indexOf(":");
+    const base = colon < 0 ? undefined : prefixes.get(t.text.slice(0, colon));
+    return base === undefined ? undefined : base + t.text.slice(colon + 1);
+  };
+  const tokens = turtleTokens(ttl);
+  let state: "subject" | "predicate" | "object" | "after" = "subject";
+  let depth = 0;
+  let subject: string | undefined;
+  let predicate: string | undefined;
+  for (let k = 0; k < tokens.length; k++) {
+    const t = tokens[k]!;
+    if (t.kind === "name" && /^(@prefix|PREFIX)$/i.test(t.text) && state === "subject" && depth === 0) {
+      const name = tokens[k + 1]?.text ?? "";
+      const iri = tokens[k + 2];
+      if (iri?.kind === "iri") prefixes.set(name.replace(/:$/, ""), iri.text);
+      k += t.text.startsWith("@") ? 3 : 2;
+      continue;
+    }
+    if (t.kind === "name" && /^(@base|BASE)$/i.test(t.text) && state === "subject" && depth === 0) {
+      k += t.text.startsWith("@") ? 2 : 1;
+      continue;
+    }
+    if (t.kind === "punct" && (t.text === "[" || t.text === "(")) {
+      if (depth++ === 0 && state === "subject") subject = undefined;
+      continue;
+    }
+    if (t.kind === "punct" && (t.text === "]" || t.text === ")")) {
+      if (depth > 0 && --depth === 0) state = state === "subject" ? "predicate" : "after";
+      continue;
+    }
+    if (depth > 0) continue;
+    if (t.kind === "punct") {
+      if (t.text === ".") state = "subject";
+      else if (t.text === ";") state = "predicate";
+      else if (t.text === ",") state = "object";
+      continue;
+    }
+    if (state === "subject") {
+      subject = expand(t);
+      state = "predicate";
+    } else if (state === "predicate") {
+      predicate = expand(t);
+      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);
+      }
+    }
+  }
+  return [...subjects.entries()]
+    .filter(([, e]) => e.typed)
+    .map(([uri, e]) => ({ uri, files: e.files, ...(e.binary === undefined ? {} : { binary: e.binary }) }));
+}
+
+/** 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 }));
+}
+
 export const lv2Loader: PluginLoader = {
   format: "lv2",
   resolve(target: string): readonly PluginTarget[] | undefined {
@@ -55,7 +179,8 @@ const LV2_DEFAULT_DIRS = [".lv2", "/usr/lib/lv2", "/usr/lib64/lv2", "/usr/local/
 
 /**
  * Every `.lv2` bundle directly under the LV2 search path (`LV2_PATH`, else lilv's defaults). An
- * absent directory holds none; any other fs error propagates for the caller to name.
+ * absent directory holds none; any other fs error propagates for the caller to name. A bundle is
+ * a directory holding `manifest.ttl`: a dangling `.lv2` symlink or a plain `.lv2` file is not one.
  */
 export function lv2BundlesOnPath(env: Readonly<Record<string, string | undefined>>, home: string = homedir()): string[] {
   const named = (env["LV2_PATH"] ?? "").split(":").filter((d) => d !== "");
@@ -70,7 +195,17 @@ export function lv2BundlesOnPath(env: Readonly<Record<string, string | undefined
       if (code === "ENOENT" || code === "ENOTDIR") continue;
       throw e;
     }
-    for (const n of names.sort()) if (n.endsWith(".lv2")) bundles.push(join(dir, n));
+    for (const n of names.sort()) {
+      if (!n.endsWith(".lv2")) continue;
+      const path = join(dir, n);
+      let isBundle: boolean;
+      try {
+        isBundle = statSync(path).isDirectory() && existsSync(join(path, "manifest.ttl"));
+      } catch {
+        isBundle = false; // a dangling symlink
+      }
+      if (isBundle) bundles.push(path);
+    }
   }
   return bundles;
 }

package/src/measurement/cli.ts

@@ -43,6 +43,7 @@ import { measuredPluginsFromSweep } from "./sweep-jsonl.js";
 import { isRecord, nonEmptyString } from "./guards.js";
 import { HOSTING_PASS_DIMENSIONS, type MeasurementDimension, PROBED_DIMENSIONS } from "./vocabulary.js";
 import { LV2_HOSTING_BLOCK_FRAMES, LV2_HOSTING_LIFECYCLES, LV2_HOSTING_REPEATS } from "../qualify-declarations.js";
+import { extractJsonRecord } from "../measure-host.js";
 
 /** Name and version this tool stamps into every document it writes. */
 export const TOOL_NAME = "lv2-measure";
@@ -269,26 +270,19 @@ export interface HostingRunResult {
 }
 
 /**
- * One plugin's run of the native measurer as the hosting sweep's JSONL line: the LAST line of its
- * stdout that is a JSON object (a plugin may print its own banner first), with the exit status
- * beside it, a death written as 128 + its signal and a timeout as 124. A run that printed no line
- * is `crashed`, its exit kept: what that exit means is the reader's (`sweep-jsonl.ts`) to say.
+ * One plugin's run of the native measurer as the hosting sweep's JSONL line: its stdout's JSON
+ * record ({@link extractJsonRecord}, which repairs a plugin's banner printed into the middle of
+ * the line), with the exit status beside it, a death written as 128 + its signal and a timeout
+ * as 124. A run whose stdout had a `{`-leading line that never repaired is `parseError`; one
+ * with no such line at all is `crashed`. Either way the exit is kept: what it means is the
+ * reader's (`sweep-jsonl.ts`) to say.
  */
 export function hostingLine(uri: string, run: HostingRunResult): Record<string, unknown> {
   const exit = run.timedOut === true ? 124 : run.signalNumber !== undefined ? 128 + run.signalNumber : (run.status ?? 1);
-  const last = run.stdout
-    .split("\n")
-    .filter((line) => line.startsWith("{"))
-    .pop();
-  if (last !== undefined) {
-    try {
-      const row: unknown = JSON.parse(last);
-      if (isRecord(row)) return { ...row, exit };
-    } catch {
-      return { uri, exit, parseError: true };
-    }
-  }
-  return { uri, exit, crashed: true };
+  const row = extractJsonRecord(run.stdout);
+  if (row !== undefined) return { ...row, exit };
+  const hadCandidate = run.stdout.split("\n").some((line) => line.startsWith("{"));
+  return hadCandidate ? { uri, exit, parseError: true } : { uri, exit, crashed: true };
 }
 
 // ---------------------------------------------------------------------------

package/src/pins-file.ts

@@ -16,6 +16,7 @@ import { resolve } from "node:path";
 
 import type { RtSafetyDocument } from "./clap-qualify.js";
 import type { IntegrityMeasurement, MeasuredPlugin } from "./measurement/format.js";
+import { integrityOfProbeOutput, type Judgment } from "./probe-judge.js";
 import type { QualifyVerdict } from "./qualify-cli.js";
 import type { SuitabilityRating } from "./rating.js";
 
@@ -86,11 +87,11 @@ export interface PinsFile {
 }
 
 /**
- * The file: a comment that says where it came from, then one line per plugin, sorted by uri. A uri given twice keeps
+ * The file: a comment that says which command wrote it, then one line per plugin, sorted by uri. A uri given twice keeps
  * the entry whose verdict is the worse one (`refused` over `isolated` over `in-process`, no word over all), so a
  * plugin found twice is never pinned more kindly than its worst measurement.
  */
-export function pinsFile(entries: readonly PinEntry[]): PinsFile {
+export function pinsFile(entries: readonly PinEntry[], writer = "plugin-qualify --pins"): PinsFile {
   const byUri = new Map<string, string>();
   const verdictOf = new Map<string, PinVerdict | undefined>();
   const skipped: string[] = [];
@@ -114,7 +115,7 @@ export function pinsFile(entries: readonly PinEntry[]): PinsFile {
   }
   const uris = [...byUri.keys()].sort();
   const text = [
-    "# written by plugin-qualify --pins; plugin-hostd reads it with pin_file",
+    `# written by ${writer}; plugin-hostd reads it with pin_file`,
     ...uris.map((u) => byUri.get(u)!),
     "",
   ].join("\n");
@@ -138,6 +139,19 @@ export function clapPinEntries(documents: readonly RtSafetyDocument[], host: str
     });
 }
 
+/**
+ * The entry of one judged probe output for one host, CLAP or LV2: the pin the run took and the verdict that host's
+ * judgment gives it. A run that did not finish has no verdict word; a host the judgment does not hold, no entry.
+ */
+export function judgmentPinEntries(judgment: Judgment, host: string): PinEntry[] {
+  const judged = judgment.hosts.find((h) => h.verdict.host === host);
+  if (judged === undefined) return [];
+  const o = judgment.output;
+  const uri = o.plugin.format === "clap" ? clapPinUri(o.binary.path, `urn:clap:${o.plugin.id}`) : o.plugin.id;
+  const verdict = judged.verdict.measured ? pinVerdictOf(judged.verdict.rating) : undefined;
+  return [{ uri, integrity: integrityOfProbeOutput(o), ...(verdict === undefined ? {} : { verdict }) }];
+}
+
 /**
  * The entries of an LV2 run: each measured plugin with a pin and the verdict row of that host. A plugin with no verdict
  * row for the host is pinned without a verdict word.

package/src/probe-judge.ts

@@ -33,6 +33,7 @@ import {
   type HostingReason,
 } from "./hosting-suitability.js";
 import type { HostProfile } from "./host-profiles.js";
+import { admittedHostOf, type HostAdmission } from "./host-admission.js";
 import { PROBE_NOT_ATTEMPTED, PROBE_OK, type ProbeGridPoint, type ProbeOutput } from "./probe-output.js";
 import type { QualifyVerdict } from "./qualify-cli.js";
 import { RATING_SEVERITY, worstRating, type SuitabilityRating } from "./rating.js";
@@ -42,6 +43,11 @@ import type { IntegrityMeasurement, VoicesHeld } from "./measurement/format.js";
 export interface JudgeFacts {
   /** Note input ports the plugin declares. */
   readonly noteInputs?: number;
+  /**
+   * The plugin run under each measured host, by profile id (`host-admission.ts`). A profile that has one is
+   * judged by it as well as by its declaration; one that has none is judged from its declaration alone.
+   */
+  readonly admissions?: Readonly<Record<string, HostAdmission>>;
 }
 
 /** A sum of one count over the points, or `undefined` when a point lacks it: a missing count is not zero. */
@@ -102,7 +108,8 @@ function noteSweepOfProbeOutput(output: ProbeOutput, rt: ClapRtSafetyReading): C
   };
 }
 
-function integrityOfProbeOutput(output: ProbeOutput): IntegrityMeasurement {
+/** The pin a probe output took: its files and layout, or why it has none. */
+export function integrityOfProbeOutput(output: ProbeOutput): IntegrityMeasurement {
   const { files, layout, unpinnable } = output.binary;
   if (layout === undefined || files.length === 0) {
     return { unmeasuredReason: unpinnable === undefined ? "probe-error" : "unpinnable", unmeasuredDetail: unpinnable ?? "the probe output holds no layout pin" };
@@ -168,6 +175,8 @@ export interface HostJudgment {
   readonly verdict: QualifyVerdict;
   /** In-process only for a suitable plugin on a host that runs its plugins in its own process, else isolated. */
   readonly hosting: "in-process" | "isolated";
+  /** `run` when the plugin was run under this host, `declaration` when the verdict is only what the profile's declaration makes of the probe output. */
+  readonly arm: "run" | "declaration";
   readonly reasons: readonly RecordReason[];
   /**
    * The cost reasons at this host's rate and quantum, kept beside the verdict, not folded into it; for an instrument,
@@ -228,6 +237,7 @@ export function judgeProbeOutput(output: ProbeOutput, profiles: readonly HostPro
       hosts: profiles.map((profile) => ({
         verdict: { uri, host: profile.id, measured: false, rating: "unknown", qualified: false, deciding: failure },
         hosting: "isolated",
+        arm: "declaration",
         reasons: [reason],
         cost: costOf(output, profile),
       })),
@@ -247,6 +257,21 @@ export function judgeProbeOutput(output: ProbeOutput, profiles: readonly HostPro
       const notes = noteSweepOfProbeOutput(output, rt);
       reasons = [...rtSafetyReasons(rt), ...noteSweepReasons(notes, facts.noteInputs ?? (notes.applicable ? 1 : 0))].map(asRecordReason);
     }
+    const admission = facts.admissions?.[profile.id];
+    if (admission !== undefined && admittedHostOf(profile) !== undefined) {
+      if (!admission.measured || !admission.admitted) {
+        // the host could not be run, or the plugin did not survive it: the run decides, whatever the declaration says
+        const code = admission.code ?? `${admission.host}.not-admitted`;
+        const reason: RecordReason = { dimension: "hostAdmission", rating: admission.measured ? "unsuitable" : "unknown", code, params: admission.params };
+        return {
+          verdict: { uri, host: profile.id, measured: admission.measured, rating: reason.rating, qualified: false, deciding: code },
+          hosting: "isolated",
+          arm: "run",
+          reasons: [reason, ...reasons],
+          cost: costOf(output, profile),
+        };
+      }
+    }
     const rating = worstRating(reasons.map((r) => r.rating));
     const deciding = decidingOf(reasons, rating);
     return {
@@ -259,6 +284,7 @@ export function judgeProbeOutput(output: ProbeOutput, profiles: readonly HostPro
         ...(deciding === undefined ? {} : { deciding: deciding.code }),
       },
       hosting: rating === "suitable" && profile.isolation === "in-process" ? "in-process" : "isolated",
+      arm: admission !== undefined && admittedHostOf(profile) !== undefined ? "run" : "declaration",
       reasons,
       cost: costOf(output, profile),
     };

package/src/probe-output-fixtures.ts

@@ -144,3 +144,89 @@ export function clapLineFixture(patch: {
   };
 }
 
+
+/** One LV2 measurer line, as `lv2_measure` prints it: the keys the translation reads. */
+export type Lv2MeasureLine = Record<string, any>;
+
+/**
+ * The probe output the runner writes for an LV2 measurer line: the grid point of the run's rate and block with what
+ * run() did under the interposer, and, under the same field names as a CLAP point, the `latency` and `cost` the line holds
+ * at that rate. A latency or cost the line could not take is no field of the point: it is a step that says so, with the
+ * hosting code, and the run still ends `probe.ok`. The runner's translation in the small (plugin-hostd's `put_lv2_measure`), as
+ * `probeOutputOfLine` is its CLAP one, so a record is read from a real measurement through the real reader.
+ */
+export function probeOutputOfLv2Line(line: Lv2MeasureLine): Record<string, any> {
+  const doc = fixtureJson("success-msi");
+  const rate = Number(line["rate"]);
+  const quantum = Number(line["block"]);
+  const rt = line["rtSafety"];
+  const key = String(rate);
+  const latency = line["latency"]?.[key];
+  const cost = line["cost"]?.perRate?.[key];
+  const pin = line["integrity"];
+  doc["plugin"] = { format: "lv2", id: line["uri"], ...(pin?.version === undefined ? {} : { version: pin.version }) };
+  doc["binary"] = {
+    path: pin?.files?.find((f: { path: string }) => !f.path.endsWith(".ttl"))?.path ?? "plugin.so",
+    sha256: pin?.files?.find((f: { path: string }) => !f.path.endsWith(".ttl"))?.sha256 ?? "0".repeat(64),
+    files: pin?.files ?? [],
+    ...(pin?.layout === undefined ? {} : { layout: pin.layout }),
+  };
+  delete doc["descriptor"];
+  doc["offer"] = { id: "default", realtime: "none" };
+  const steps: Record<string, unknown>[] = [
+    { step: "hash", outcome: "probe.ok", elapsedMs: 1 },
+    { step: "instantiate", outcome: "probe.ok", elapsedMs: 1 },
+    { step: "rt-safety", rate, quantum, outcome: "probe.ok", elapsedMs: 1 },
+  ];
+  const absent = (step: "latency" | "cost", at: any): void => {
+    steps.push({
+      step,
+      rate,
+      quantum,
+      outcome: "probe.not-attempted",
+      elapsedMs: 1,
+      hostingCode: step === "latency" ? "hosting.latency.unmeasured" : "hosting.cost.unmeasured-at-rate-and-quantum",
+      detail: `${at?.unmeasuredReason ?? "not-attempted"}: ${at?.unmeasuredDetail ?? "the measurer's line holds no figure"}`,
+    });
+  };
+  const point: Record<string, unknown> = { rate, quantum, outcome: "probe.ok" };
+  if (latency?.measuredFrames !== undefined) {
+    steps.push({ step: "latency", rate, quantum, outcome: "probe.ok", elapsedMs: 1 });
+    point["latency"] = {
+      declaredFrames: latency.declaredFrames,
+      measuredFrames: latency.measuredFrames,
+      method: latency.from === "note" ? "note-onset" : "impulse-onset",
+      ...(latency.from === "note" ? { heard: true } : {}),
+    };
+  } else absent("latency", latency);
+  if (cost?.nsPerSampleMedian !== undefined) {
+    steps.push({ step: "cost", rate, quantum, outcome: "probe.ok", elapsedMs: 1 });
+    point["cost"] = {
+      unit: "ns-per-sample",
+      median: cost.nsPerSampleMedian,
+      percentile: { p: line["cost"].percentile, value: cost.nsPerSampleP95 },
+      min: cost.nsPerSampleMin,
+      max: cost.nsPerSampleMax,
+      blocks: cost.blocks,
+      warmupBlocks: line["cost"].warmupBlocks,
+      ...(cost.voices === undefined ? {} : { voices: cost.voices }),
+    };
+  } else absent("cost", cost);
+  if (rt !== undefined) {
+    point["rtSafety"] = {
+      interposer: rt.interposer,
+      swept: rt.swept,
+      sweepApplicable: rt.sweepApplicable,
+      blocks: rt.blocks,
+      allocations: rt.allocationsInRun,
+      locks: rt.locksInRun,
+      syscalls: rt.syscallsInRun,
+      events: [],
+    };
+  }
+  point["noteSweep"] = { applicable: rt?.noteSweep?.applicable === true };
+  doc["steps"] = steps;
+  doc["grid"] = [point];
+  doc["behaviour"] = { lifecycle: line["lifecycle"], threads: line["threads"], features: { required: line["requiredFeatures"] ?? [] } };
+  return doc;
+}

package/src/probe-output.ts

@@ -102,6 +102,8 @@ export interface ProbeStep {
   readonly outcome: string;
   readonly rate?: number;
   readonly quantum?: number;
+  /** The hosting code the step carries when it says why a figure is absent (`hosting.latency.unmeasured`). */
+  readonly hostingCode?: string;
   readonly detail?: string;
 }
 
@@ -310,6 +312,7 @@ function readStep(v: unknown, i: number): ProbeStep {
     outcome: outcome(o, where),
     ...optional("rate", o["rate"] === undefined ? undefined : posInt(o, "rate", where)),
     ...optional("quantum", o["quantum"] === undefined ? undefined : posInt(o, "quantum", where)),
+    ...optional("hostingCode", nonEmptyString(o["hostingCode"])),
     ...optional("detail", nonEmptyString(o["detail"])),
   };
 }