@openmixer/plugin-qualify 0.9.0 → 0.11.0

package/src/cost-fields.ts

@@ -70,3 +70,42 @@ export function classifierCostFromDocument(reading: CostAtRate, rate: number): C
     [COST_FIELDS.classifier.coreFraction]: fraction,
   };
 }
+
+/**
+ * The key of one point of a cost grid: the rate and the quantum it was measured at. One place spells it,
+ * so the reader that fills a grid and the gate that looks a point up cannot disagree.
+ */
+export function costPointKey(rate: number, quantum: number): string {
+  return `${rate}/${quantum}`;
+}
+
+/** The percentile the classifier's `nsPerSampleP95` is. A figure taken at another percentile is not that field. */
+export const CLASSIFIER_PERCENTILE = 95;
+
+/** One point of a grid as it is measured: the figures {@link gridCostReadings} turns into the classifier's. */
+export interface CostGridPoint {
+  readonly rate: number;
+  readonly quantum: number;
+  readonly outcome: string;
+  readonly cost?: { readonly median: number; readonly percentile: { readonly p: number; readonly value: number } };
+}
+
+/**
+ * The classifier's cost readings of a grid, by {@link costPointKey}. A point that did not end `probe.ok`, has no
+ * cost, or whose percentile is not {@link CLASSIFIER_PERCENTILE} has no reading: the gate then reads the pair as
+ * unmeasured, which is the truth, where a figure under the wrong name would be judged as if it were the P95.
+ */
+export function gridCostReadings(points: readonly CostGridPoint[], okOutcome: string): Record<string, ClassifierCostReading> {
+  const out: Record<string, ClassifierCostReading> = {};
+  for (const p of points) {
+    if (p.outcome !== okOutcome || p.cost === undefined || p.cost.percentile.p !== CLASSIFIER_PERCENTILE) continue;
+    const fraction = coreFraction(p.cost.percentile.value, p.rate);
+    if (fraction === undefined) continue;
+    out[costPointKey(p.rate, p.quantum)] = {
+      [COST_FIELDS.classifier.median]: p.cost.median,
+      [COST_FIELDS.classifier.percentile]: p.cost.percentile.value,
+      [COST_FIELDS.classifier.coreFraction]: fraction,
+    };
+  }
+  return out;
+}

package/src/host-profiles.ts

@@ -54,6 +54,17 @@ export const OMX_CLAP_HOST_EXTENSIONS: readonly string[] = [
   "clap.state",
 ];
 
+/**
+ * The three host extensions omx-clap-host turns on beyond the library's own (omx-clap-core
+ * `src/effects.c` `configure_core`: `preset_load`, `track_info`, `remote_controls`), by the ids
+ * its host object answers (`src/clap_host.c`); the prober offers them with `--offer`.
+ */
+export const OMX_CLAP_HOST_CONFIGURED_EXTENSIONS: readonly string[] = [
+  "clap.preset-load/2",
+  "clap.track-info/1",
+  "clap.remote-controls/2",
+];
+
 /** The LV2 extension namespace the jalv and mod-host lists are spelled in. */
 const LV2_EXT = "http://lv2plug.in/ns/ext/";
 const BUF_SIZE_ALL = ["powerOf2BlockLength", "fixedBlockLength", "boundedBlockLength"].map((f) => `${LV2_EXT}buf-size#${f}`);
@@ -113,8 +124,25 @@ export const MOD_HOST_PROFILE: HostProfile = {
   isolation: "shared-process",
 };
 
+/**
+ * omx-clap-host, alone or as plugin-hostd's CLAP worker: one JACK client per plugin in a host
+ * process that several plugins may share (a plugin-hostd pool), instruments fed through each
+ * client's `midi_in`, latency published on the JACK ports. Its CLAP host object is the library's
+ * plus the three it configures; its LV2 plugins run through the same feature provider as the
+ * console's in-process stage.
+ */
+export const OMX_CLAP_HOST_PROFILE: HostProfile = {
+  id: "omx-clap-host",
+  lv2Features: OMX_INPROCESS_FEATURES,
+  clapExtensions: [...OMX_CLAP_HOST_EXTENSIONS, ...OMX_CLAP_HOST_CONFIGURED_EXTENSIONS],
+  instruments: true,
+  cost: HOST_BUDGETS["omx-clap-host"],
+  latency: "uncompensated",
+  isolation: "shared-process",
+};
+
 /** Every profile the tool ships, by id. */
-export const HOST_PROFILES: readonly HostProfile[] = [OPENMIXER_CONSOLE_PROFILE, JALV_PROFILE, MOD_HOST_PROFILE];
+export const HOST_PROFILES: readonly HostProfile[] = [OPENMIXER_CONSOLE_PROFILE, JALV_PROFILE, MOD_HOST_PROFILE, OMX_CLAP_HOST_PROFILE];
 
 /** A shipped profile by id, or `undefined`. */
 export function shippedHostProfile(id: string): HostProfile | undefined {

package/src/hosting-codes.ts

@@ -1,10 +1,10 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 // Copyright (C) 2026 Pau Aliagas <linuxnow@gmail.com>
 /**
- * The hosting verdict's message codes (2026-09-04-lv2-hosting-path.md). Codes, never prose: the
+ * The hosting verdict's message codes. Codes, never prose: the
  * surface renders the operator's locale.
  *
- * A UNION list file (2026-09-15-no-stored-derivations.md §9): `.gitattributes` marks it
+ * A UNION list file: `.gitattributes` marks it
  * `merge=union`, so two lanes that each add a code merge with both kept. Only the table lives
  * here, one `key: 'code',` per line, with keys and codes unique; the registry-hotspots gate
  * refuses anything else.
@@ -24,6 +24,10 @@ export const HOSTING_CODE = {
   rtSafetyViolations: 'hosting.rt-safety.violations-in-run',
   rtSafetyUnmeasured: 'hosting.rt-safety.unmeasured',
   rtSafetyNotReproducible: 'hosting.rt-safety.not-reproducible',
+  // The note sweep: an instrument played under the interposer, a count of its own.
+  rtSafetyNotesClean: 'hosting.rt-safety.clean-under-notes',
+  rtSafetyNotesViolations: 'hosting.rt-safety.violations-under-notes',
+  rtSafetyNotesUnmeasured: 'hosting.rt-safety.notes-unmeasured',
   featuresProvided: 'hosting.features.all-provided',
   featuresMissing: 'hosting.features.required-not-provided',
   featuresDisqualifying: 'hosting.features.host-not-provided',
@@ -44,7 +48,7 @@ export const HOSTING_CODE = {
   topologyNoAudioOutput: 'hosting.topology.no-audio-output',
   topologyExtraInputs: 'hosting.topology.extra-inputs-fed-silence',
   topologyInstrument: 'hosting.topology.instrument',
-  // The CLAP arm (2026-09-26-clap-hosting-path.md §3): the SAME dimensions fed from CLAP facts,
+  // The CLAP arm: the SAME dimensions fed from CLAP facts,
   // minted here where the LV2 table has no code for the fact.
   topologyWiderThanStrip: 'hosting.topology.wider-than-strip',
   clapLatencyMismatch: 'hosting.clap.latency-mismatch',
@@ -57,6 +61,7 @@ export const HOSTING_CODE = {
   clapFormatNotHosted: 'hosting.clap.format-not-hosted',
   clapExtensionsNotCovered: 'hosting.clap.extensions-not-covered',
   outputNonFinite: 'hosting.output.non-finite',
+  workerNonconforming: 'hosting.worker.nonconforming',
   // The pin (spec §11; one-contract §10.3): a host's refusal at add, by the daemon's code.
   integrityUnpinned: 'hosting.integrity.unpinned',
   integrityBinaryMismatch: 'hosting.integrity.binary-mismatch',
@@ -72,6 +77,6 @@ export const HOSTING_CODE = {
   noRealisation: 'hosting.no-realisation',
   realisedInProcess: 'hosting.realised.in-process',
   // A plugin LINKED into the engine (the static-link registry) runs in-process without a
-  // verdict: the library's oracles are its proof (`2026-09-26-clap-hosting-path.md` §7).
+  // verdict: the library's oracles are its proof.
   linked: 'hosting.linked',
 } as const;

package/src/hosting-suitability.ts

@@ -52,11 +52,19 @@ export interface QualifiedPlugin {
     readonly scalingClass?: string;
     readonly paramSweep?: unknown;
   };
-  /** Measured cost per rate (Hz as a string key). */
+  /** Measured cost: per rate (Hz as a string key), or per rate AND quantum. */
   readonly cpuCost?: {
+    /** One figure per rate, at the block the prober ran: the old format. Read only when `perRateQuantum` is absent. */
     readonly perRate?: Readonly<
       Record<string, { readonly coreFractionP95: number; readonly nsPerSampleMedian: number; readonly nsPerSampleP95: number }>
     >;
+    /**
+     * One figure per rate and quantum, keyed by {@link costPointKey}: a probe output's grid. When this is
+     * present it is the only cost there is, so a pair it lacks is unmeasured, never read from `perRate`.
+     */
+    readonly perRateQuantum?: Readonly<
+      Record<string, { readonly coreFractionP95: number; readonly nsPerSampleMedian: number; readonly nsPerSampleP95: number }>
+    >;
   };
   readonly stability?: PluginStabilityMeasurement;
   readonly rtSafety?: PluginRtSafetyMeasurement;
@@ -199,12 +207,12 @@ export interface CrashSignature {
   /** The top plugin-owned stack frame, or a host frame that exonerates the plugin. */
   readonly topFrame: string;
   readonly signal?: "SIGSEGV" | "SIGABRT" | "SIGBUS";
-  /** The note that recorded this cluster. Provenance, so a row is never folklore. */
+  /** What was found about this cluster. Provenance, so a row is never folklore. */
   readonly note: string;
 }
 
 /**
- * Seeded from the crash notes of 2026-09-03/04. A raw crash matching NO row is
+ * Seeded from the crashes investigated on 2026-09-03/04. A raw crash matching NO row is
  * `unknown` — the table blames a plugin only where a named investigation did.
  */
 export const CRASH_SIGNATURES: readonly CrashSignature[] = [
@@ -213,26 +221,26 @@ export const CRASH_SIGNATURES: readonly CrashSignature[] = [
     attribution: "host",
     topFrame: "pw_memmap_free",
     signal: "SIGSEGV",
-    note: "2026-09-04-pipewire-jack-client-close-double-free.md",
+    note: "closing a PipeWire JACK client frees a memory map twice; the host crashes, not the plugin",
   },
   {
     id: "pipewire-jack-close-double-free-abort",
     attribution: "host",
     topFrame: "tcache_double_free_verify",
     signal: "SIGABRT",
-    note: "2026-09-04-pipewire-jack-client-close-double-free.md",
+    note: "the same double free in PipeWire's JACK client close, caught by glibc's tcache check as an abort",
   },
   {
     id: "mod-host-effects-remove",
     attribution: "host",
     topFrame: "effects_remove",
-    note: "2026-09-03-mod-host-crash-cluster2-3-investigation.md",
+    note: "mod-host crashes in effects_remove while removing an effect; the host is at fault",
   },
   {
     id: "plugin-instantiate-layout",
     attribution: "plugin",
     topFrame: "lilv_instance_instantiate",
-    note: "2026-09-03-mod-host-crash-cluster2-3-investigation.md",
+    note: "the plugin crashes while lilv instantiates it, on a port layout it cannot host",
   },
 ];
 
@@ -306,7 +314,7 @@ export type PluginLv2Features = Omit<FeaturesMeasurement, "unmeasuredReason" | "
 
 export { DEFAULT_HOSTING_POLICY, type HostingPolicy } from "./qualify-declarations.js";
 import { DEFAULT_HOSTING_POLICY, type HostingPolicy } from "./qualify-declarations.js";
-import { costFieldsMissing } from "./cost-fields.js";
+import { costFieldsMissing, costPointKey } from "./cost-fields.js";
 
 /** One declared rate's latency reading from the CLAP qualifier (CLAP spec §3, latency). */
 export interface ClapLatencyAtRate {
@@ -342,6 +350,28 @@ export interface PluginClapMeasurement {
   readonly processCalls: number;
 }
 
+/**
+ * The note sweep of a CLAP plugin with a note input (plugin-qualify's prober): the plugin played at
+ * every rate — a chord, bend and a controller, pressure, the chord let go, a burst of note ons and
+ * their offs, all notes off — in the dialect its first note input reads, counted under the
+ * interposer apart from the parameter sweep. `applicable: false` is a plugin the prober could not
+ * play: no note input, or none in a dialect it speaks.
+ */
+export interface PluginNoteSweepMeasurement {
+  readonly applicable: boolean;
+  readonly dialect?: "clap" | "midi";
+  readonly blocks?: number;
+  readonly blockFrames?: number;
+  /** Note, expression and MIDI events the sweep sent. */
+  readonly noteEvents?: number;
+  readonly processErrors?: number;
+  readonly nonFinite?: boolean;
+  readonly interposer?: boolean;
+  readonly allocationsInRun?: number;
+  readonly locksInRun?: number;
+  readonly syscallsInRun?: number;
+}
+
 /** What the classifier is told about the console asking. */
 export interface HostingClassifyOptions {
   /** The LIVE rate. Cost is read here and nowhere else — never projected. */
@@ -678,7 +708,13 @@ export function hostingCostReasons(
   options: HostingClassifyOptions,
   policy: HostingPolicy,
 ): readonly HostingReason[] {
-  const perRate = descriptor.cpuCost?.perRate?.[String(options.rate)];
+  const grid = descriptor.cpuCost?.perRateQuantum;
+  const perRate =
+    grid === undefined
+      ? descriptor.cpuCost?.perRate?.[String(options.rate)]
+      : options.quantum === undefined
+        ? undefined
+        : grid[costPointKey(options.rate, options.quantum)];
   if (perRate === undefined) {
     return [
       reason("cost", "objective", "unknown", HOSTING_CODE.costUnmeasured, {
@@ -739,6 +775,10 @@ export function hostingLatencyReasons(
   // one the benchmark declared unmeasurable, has not been judged and does not pass by
   // default. The oracle's first fixture omitted latency and still expected `suitable`,
   // which is how this branch was missing — a self-consistent suite proving nothing.
+  // A plugin whose worker interface was refused is not unmeasured by accident: it is not hostable.
+  if (typeof latency?.unmeasurable === "string" && latency.unmeasurable.includes(HOSTING_CODE.workerNonconforming)) {
+    return [reason("latency", "objective", "unsuitable", HOSTING_CODE.workerNonconforming)];
+  }
   if (latency === undefined || latency.unmeasurable !== undefined) {
     return [reason("latency", "objective", "unknown", HOSTING_CODE.latencyUnmeasured)];
   }
@@ -888,6 +928,37 @@ export function clapRtReasons(clap: PluginClapMeasurement | undefined): readonly
   return out;
 }
 
+/**
+ * The rtSafety reasons of the note sweep, for a plugin with `noteInputs` note inputs: none for a
+ * plugin that takes no notes; `unknown` when it takes notes and was not played under the
+ * interposer (an instrument is cheap and clean at rest, so the parameter sweep alone says nothing
+ * about a voice); `unsuitable` on any allocation, lock or syscall while it was played, or a process
+ * error; `suitable` on a clean count.
+ */
+export function noteSweepReasons(sweep: PluginNoteSweepMeasurement | undefined, noteInputs: number): readonly HostingReason[] {
+  if (noteInputs === 0) return [];
+  if (sweep === undefined || !sweep.applicable || sweep.interposer !== true || !sweep.blocks ||
+      sweep.allocationsInRun === undefined || sweep.locksInRun === undefined || sweep.syscallsInRun === undefined) {
+    return [reason("rtSafety", "objective", "unknown", HOSTING_CODE.rtSafetyNotesUnmeasured)];
+  }
+  const out: HostingReason[] = [];
+  if (sweep.allocationsInRun + sweep.locksInRun + sweep.syscallsInRun > 0) {
+    out.push(
+      reason("rtSafety", "objective", "unsuitable", HOSTING_CODE.rtSafetyNotesViolations, {
+        allocations: sweep.allocationsInRun,
+        syscalls: sweep.syscallsInRun,
+        locks: sweep.locksInRun,
+      }),
+    );
+  }
+  if ((sweep.processErrors ?? 0) > 0) {
+    out.push(reason("rtSafety", "objective", "unsuitable", HOSTING_CODE.clapProcessError, { errors: sweep.processErrors ?? 0 }));
+  }
+  return out.length > 0
+    ? out
+    : [reason("rtSafety", "objective", "suitable", HOSTING_CODE.rtSafetyNotesClean, { blocks: sweep.blocks, events: sweep.noteEvents ?? 0 })];
+}
+
 /**
  * The verdict. Worst-wins across every dimension, exactly as `classifyForRole` folds — with
  * three gates that can poison the whole result before the fold is even read: a curator
@@ -905,7 +976,7 @@ export function classifyPluginHosting(
   // interchange's one door (`measurement-catalog.ts`), whose per-dimension precedence is the
   // only precedence there is. A second "passed measurements win" seam here was how an offline
   // report could agree with itself while every served descriptor read unknown.
-  // The CLAP arm (2026-09-26-clap-hosting-path.md §3): the SAME six dimensions, fed from the
+  // The CLAP arm: the SAME six dimensions, fed from the
   // qualifier's CLAP facts where the LV2 scan's facts do not exist for the format. Stability,
   // the interposer's counts and the cost are format-blind and read unchanged.
   const reasons: HostingReason[] = descriptor.format === "clap"
@@ -988,7 +1059,7 @@ export interface HostingRealisation {
   readonly inProcessAvailable: boolean;
   /**
    * Whether the plugin is LINKED into the engine (its static-link registry): it needs no verdict
-   * to run in-process (`2026-09-26-clap-hosting-path.md` §7). Absent reads as not linked.
+   * to run in-process. Absent reads as not linked.
    */
   readonly linked?: boolean;
 }

package/src/index.ts

@@ -20,3 +20,8 @@ export * from "./qualify-cli.js";
 export * from "./pins-file.js";
 export * from "./measure-host.js";
 export * from "./cost-fields.js";
+export * from "./probe-output.js";
+export * from "./probe-judge.js";
+export * from "./qualification-record.js";
+export * from "./probe-runner.js";
+export * from "./judge-cli.js";

package/src/judge-cli.ts

@@ -0,0 +1,133 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Copyright (C) 2026 Pau Aliagas <linuxnow@gmail.com>
+/**
+ * `plugin-qualify judge <probe-output>...`: judge probe outputs already written (by
+ * `plugin-hostd-probe run`, by plugin-hostd's `judge_cmd`, or by hand) and write the qualification
+ * record beside a byte copy of each. `bin/plugin-qualify.mjs` only reads argv and prints.
+ */
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+import type { HostProfile } from "./host-profiles.js";
+import { judgeProbeOutput, judgmentVerdicts } from "./probe-judge.js";
+import { readProbeOutput } from "./probe-output.js";
+import { writeQualification } from "./qualification-record.js";
+import type { QualifyVerdict } from "./qualify-cli.js";
+import { EXIT_CODE, OUTPUT_FORMATS, type OutputFormat } from "./qualify-options.js";
+import { OPENMIXER_CONSOLE_PROFILE } from "./host-profiles.js";
+
+export interface JudgeArgs {
+  readonly files: readonly string[];
+  readonly hostProfiles: readonly string[];
+  readonly qualificationDir?: string;
+  readonly format: OutputFormat;
+  readonly help: boolean;
+}
+
+export type ParseJudgeResult = { ok: true; args: JudgeArgs } | { ok: false; error: string };
+
+const VALUE_FLAGS = ["--host-profile", "--qualification-dir", "--format"];
+
+export function parseJudgeArgs(argv: readonly string[]): ParseJudgeResult {
+  const files: string[] = [];
+  const specs: string[] = [];
+  let dir: string | undefined;
+  let format: string = "text";
+  let help = false;
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i]!;
+    if (!a.startsWith("--")) {
+      files.push(a);
+      continue;
+    }
+    if (a === "--help") {
+      help = true;
+      continue;
+    }
+    if (!VALUE_FLAGS.includes(a)) return { ok: false, error: `unknown option ${a}` };
+    const v = argv[++i];
+    if (v === undefined || v.startsWith("--")) return { ok: false, error: `${a} needs a value` };
+    if (a === "--host-profile") specs.push(...v.split(",").map((t) => t.trim()).filter((t) => t !== ""));
+    else if (a === "--qualification-dir") dir = v;
+    else format = v;
+  }
+  if (!(OUTPUT_FORMATS as readonly string[]).includes(format)) return { ok: false, error: `--format must be one of ${OUTPUT_FORMATS.join(", ")}` };
+  if (!help && files.length === 0) return { ok: false, error: "name at least one probe output" };
+  return {
+    ok: true,
+    args: {
+      files,
+      hostProfiles: [...new Set(specs.length > 0 ? specs : [OPENMIXER_CONSOLE_PROFILE.id])],
+      ...(dir === undefined ? {} : { qualificationDir: dir }),
+      format: format as OutputFormat,
+      help,
+    },
+  };
+}
+
+export function judgeHelpText(): string {
+  return [
+    "plugin-qualify judge — judge probe outputs and write the qualification records",
+    "",
+    "  plugin-qualify judge [options] <probe-output.json>...",
+    "",
+    "  --host-profile <file|id>      judge against this host; repeat or comma-separate for one verdict per profile",
+    `                                (default: ${OPENMIXER_CONSOLE_PROFILE.id})`,
+    "  --qualification-dir <dir>     where the records and the copies of the probe outputs go",
+    "                                (default: $XDG_STATE_HOME/omx/qualification, else ~/.local/state/omx/qualification)",
+    "  --format <json|text>          json = the records; text = plugin, verdict, deciding reason (default: text)",
+    "",
+    `exit ${EXIT_CODE.allQualified} all qualified / ${EXIT_CODE.someNotQualified} some not / ${EXIT_CODE.couldNotMeasure} something could not be read or judged`,
+    "",
+  ].join("\n");
+}
+
+/** The qualification directory when none is named: the state directory of owner spec section 6.9, per user. */
+export function defaultQualificationDir(env: Readonly<Record<string, string | undefined>>, home: string = homedir()): string {
+  const state = env["XDG_STATE_HOME"];
+  return join(state !== undefined && state !== "" ? state : join(home, ".local", "state"), "omx", "qualification");
+}
+
+export interface JudgeFilesResult {
+  readonly verdicts: readonly QualifyVerdict[];
+  readonly records: readonly { readonly recordPath: string; readonly probePath: string }[];
+  /** Each file that was refused or could not be read, with the code or the reason. */
+  readonly failures: readonly { readonly file: string; readonly problem: string }[];
+}
+
+/** Judge each file under every profile and write its record; a file that does not read is a failure, and the others go on. */
+export function judgeFiles(
+  files: readonly string[],
+  options: { profiles: readonly HostProfile[]; dir: string; read?: (path: string) => Buffer },
+): JudgeFilesResult {
+  const read = options.read ?? ((p: string) => readFileSync(p));
+  const verdicts: QualifyVerdict[] = [];
+  const records: { recordPath: string; probePath: string }[] = [];
+  const failures: { file: string; problem: string }[] = [];
+  for (const file of files) {
+    let bytes: Buffer;
+    try {
+      bytes = read(file);
+    } catch (e) {
+      failures.push({ file, problem: `cannot read: ${e instanceof Error ? e.message : String(e)}` });
+      continue;
+    }
+    const r = readProbeOutput(bytes.toString("utf8"));
+    if (!r.ok) {
+      failures.push({ file, problem: `${r.code}: ${r.problem}` });
+      continue;
+    }
+    const judgment = judgeProbeOutput(r.output, options.profiles);
+    const w = writeQualification(options.dir, bytes, judgment);
+    records.push({ recordPath: w.recordPath, probePath: w.probePath });
+    verdicts.push(...judgmentVerdicts(judgment));
+  }
+  return { verdicts, records, failures };
+}
+
+/** 2 when a file could not be judged or a plugin was not measured, else 0 when every verdict qualifies, else 1. */
+export function judgeExitCode(result: JudgeFilesResult): number {
+  if (result.failures.length > 0 || result.verdicts.length === 0 || result.verdicts.some((v) => !v.measured)) return EXIT_CODE.couldNotMeasure;
+  return result.verdicts.every((v) => v.qualified) ? EXIT_CODE.allQualified : EXIT_CODE.someNotQualified;
+}

package/src/measure-host.ts

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 // Copyright (C) 2026 Pau Aliagas <linuxnow@gmail.com>
 /**
- * Reading what the measuring host (`lv2_measure`) prints and supervising how long it may take
- * (`2026-09-25-plugin-qualify.md` §2a). Pure functions: the runner spawns, these decide.
+ * Reading what the measuring host (`lv2_measure`) prints and supervising how long it may take.
+ * Pure functions: the runner spawns, these decide.
  */
 import { isRecord } from "./measurement/guards.js";
 import { SOAK_SWEEP_DB, SOAK_SWEEP_RATIO, SOAK_TIMEOUT_FLOOR_S, SOAK_TIMEOUT_MARGIN } from "./qualify-declarations.js";

package/src/measurement/format.ts

@@ -464,7 +464,7 @@ export interface HostBudget {
 }
 
 /**
- * A HOST PROFILE (`2026-09-25-plugin-qualify.md` §3a; §3b here): the host a verdict was judged
+ * A HOST PROFILE: the host a verdict was judged
  * against — only what differs between hosts. A document carries every profile its verdicts name,
  * in full, so a verdict against a project's own profile is reproducible from the document alone.
  */

package/src/measurement/probe-json.ts

@@ -55,6 +55,7 @@ export const PROBE_REASON_RULES: readonly ReasonRule[] = [
   { match: /^no-audio-in$/, code: "no-audio-in" },
   { match: /^no-audio-out$/, code: "no-audio-out" },
   { match: /^silent-output$/, code: "silent-output" },
+  { match: /hosting\.worker\.nonconforming/, code: "worker-nonconforming" },
   { match: /worker crashed|worker desync|worker unavailable/, code: "probe-crashed" },
   { match: /timed out|timeout/, code: "probe-timeout" },
   { match: /non-finite/, code: "non-finite-output" },

package/src/measurement/vocabulary.ts

@@ -112,6 +112,13 @@ export const UNMEASURED_TERMS: readonly UnmeasuredTerm[] = [
       "The URI was not present in this machine's LV2 world. A fact about this installation, " +
       "not about the plugin — another host may well have it.",
   },
+  {
+    code: "worker-nonconforming",
+    kind: "probe-failed",
+    description:
+      "The plugin's LV2_Worker_Interface leaves work or work_response NULL, which the LV2 worker " +
+      "specification does not allow: it was refused before any call, not measured.",
+  },
   {
     code: "probe-error",
     kind: "probe-failed",
@@ -302,7 +309,7 @@ export function readDimension(value: unknown): MeasurementDimension | undefined
 export const VERDICT_RATINGS = ["suitable", "conditional", "unknown", "unsuitable"] as const;
 export type VerdictRating = (typeof VERDICT_RATINGS)[number];
 
-/** How a host runs its plugins (`2026-09-25-plugin-qualify.md` §3a). */
+/** How a host runs its plugins. */
 export const HOST_ISOLATIONS = ["in-process", "per-process", "shared-process"] as const;
 export type HostIsolation = (typeof HOST_ISOLATIONS)[number];