@openmixer/plugin-qualify 0.8.0 → 0.10.1

package/src/clap-qualify.ts

@@ -24,12 +24,19 @@ import {
   HOSTING_CODE,
   clapRtReasons,
   contributedHostingRating,
+  noteSweepReasons,
   rtSafetyReasons,
   type HostingReason,
   type PluginClapMeasurement,
+  type PluginNoteSweepMeasurement,
   type PluginRtSafetyMeasurement,
 } from "./hosting-suitability.js";
-import { OPENMIXER_CONSOLE_PROFILE, type HostProfile } from "./host-profiles.js";
+import {
+  OMX_CLAP_HOST_CONFIGURED_EXTENSIONS,
+  OMX_CLAP_HOST_EXTENSIONS,
+  OPENMIXER_CONSOLE_PROFILE,
+  type HostProfile,
+} from "./host-profiles.js";
 import type { PluginTarget } from "./loader.js";
 import type { QualifyVerdict } from "./qualify-cli.js";
 import { RATING_SEVERITY, worstRating, type SuitabilityRating } from "./rating.js";
@@ -51,6 +58,12 @@ export interface ClapRtSafetyReading extends PluginRtSafetyMeasurement {
   readonly events?: readonly string[];
 }
 
+/** What the note sweep counted; `applicable: false` is a plugin the prober did not play. */
+export interface ClapNoteSweepReading extends PluginNoteSweepMeasurement {
+  /** The first events the interposer recorded inside `process()` while the plugin was played. */
+  readonly events?: readonly string[];
+}
+
 /** The CLAP facts as the prober printed them: the measurement, and whether any output was not finite. */
 export interface ClapProbedFacts extends PluginClapMeasurement {
   readonly nonFinite: boolean;
@@ -65,6 +78,8 @@ export interface ClapQualifyLine {
   readonly hostExtensions: readonly string[];
   readonly clap: ClapProbedFacts;
   readonly rtSafety: ClapRtSafetyReading;
+  /** The note sweep: the plugin played through its note input, counted apart. */
+  readonly noteSweep: ClapNoteSweepReading;
   /**
    * The pin (spec §11): the `.clap`'s digest by its name in its directory and the layout fingerprint
    * the prober computed through plugin-hostd's `pin.h`, or the reason it took none.
@@ -143,6 +158,31 @@ function readRtSafety(v: unknown): ClapRtSafetyReading {
   };
 }
 
+function readNoteSweep(v: unknown): ClapNoteSweepReading {
+  if (!isRecord(v)) return bad("no noteSweep");
+  if (!bool(v, "applicable", "noteSweep")) return { applicable: false };
+  const dialect = str(v, "dialect", "noteSweep");
+  if (dialect !== "clap" && dialect !== "midi") return bad(`noteSweep dialect ${dialect}`);
+  const played = {
+    applicable: true,
+    dialect,
+    blocks: count(v, "blocks", "noteSweep"),
+    blockFrames: count(v, "blockFrames", "noteSweep"),
+    noteEvents: count(v, "noteEvents", "noteSweep"),
+    processErrors: count(v, "processErrors", "noteSweep"),
+    nonFinite: bool(v, "nonFinite", "noteSweep"),
+  } as const;
+  if (!bool(v, "interposer", "noteSweep")) return { ...played, interposer: false };
+  return {
+    ...played,
+    interposer: true,
+    allocationsInRun: count(v, "allocationsInRun", "noteSweep"),
+    locksInRun: count(v, "locksInRun", "noteSweep"),
+    syscallsInRun: count(v, "syscallsInRun", "noteSweep"),
+    events: strings(v, "events", "noteSweep"),
+  };
+}
+
 /** One line of the prober's stdout, or a {@link ClapQualifyError} saying how it differs. */
 export function parseClapQualifyLine(text: string): ClapQualifyLine {
   let v: unknown;
@@ -167,6 +207,7 @@ export function parseClapQualifyLine(text: string): ClapQualifyLine {
     hostExtensions: strings(v, "hostExtensions", "the line"),
     clap: readClap(v["clap"]),
     rtSafety: readRtSafety(v["rtSafety"]),
+    noteSweep: readNoteSweep(v["noteSweep"]),
     integrity: readIntegrity(v["integrity"]) ?? bad("no integrity"),
   };
 }
@@ -178,8 +219,13 @@ export function parseClapQualifyOutput(stdout: string): ClapQualifyLine[] {
 
 // --- the verdict document ------------------------------------------------------------------------
 
-/** The document's schema name; a reader refuses any other. */
-export const RT_SAFETY_DOCUMENT_SCHEMA = "plugin-qualify.rt-safety/1";
+/**
+ * The document's schema name; a reader refuses any other it does not know. `/2` is `/1` with
+ * `measured.noteSweep` added and the note sweep's reasons folded into `verdict` (a plugin with no
+ * note input gets none, so its `/2` verdict is its `/1` verdict); every `/1` field is unchanged, so
+ * a `/1` reader of `verdict.rating` and `verdict.rtSafe` reads a `/2` document right.
+ */
+export const RT_SAFETY_DOCUMENT_SCHEMA = "plugin-qualify.rt-safety/2";
 
 /**
  * The RT-safety verdict of one plugin binary for one console: keyed by the binary's SHA-256 and
@@ -207,6 +253,7 @@ export interface RtSafetyDocument {
     readonly hostExtensions: readonly string[];
     readonly clap: ClapProbedFacts;
     readonly rtSafety: ClapRtSafetyReading;
+    readonly noteSweep: ClapNoteSweepReading;
     readonly integrity: IntegrityMeasurement;
   };
 }
@@ -225,7 +272,7 @@ export function rtSafetyDocument(line: ClapQualifyLine, profile: HostProfile = O
     offered === null
       ? [{ dimension: "rtSafety", kind: "objective", rating: "unknown", code: HOSTING_CODE.clapFormatNotHosted, params: {} }]
       : offeredAsProfile
-        ? [...rtSafetyReasons(line.rtSafety), ...clapRtReasons(line.clap)]
+        ? [...rtSafetyReasons(line.rtSafety), ...clapRtReasons(line.clap), ...noteSweepReasons(line.noteSweep, line.clap.noteInputs)]
         : [
             {
               dimension: "rtSafety",
@@ -244,7 +291,13 @@ export function rtSafetyDocument(line: ClapQualifyLine, profile: HostProfile = O
     plugin: { uri: line.uri, format: "clap", binary: line.binary },
     console: profile.id,
     verdict: { rating, rtSafe: rating === "suitable", ...(rating === "suitable" || deciding === undefined ? {} : { deciding }), reasons },
-    measured: { hostExtensions: line.hostExtensions, clap: line.clap, rtSafety: line.rtSafety, integrity: line.integrity },
+    measured: {
+      hostExtensions: line.hostExtensions,
+      clap: line.clap,
+      rtSafety: line.rtSafety,
+      noteSweep: line.noteSweep,
+      integrity: line.integrity,
+    },
   };
 }
 
@@ -303,6 +356,8 @@ export interface ClapQualifyOptions {
   readonly env?: Readonly<Record<string, string | undefined>>;
   /** Whether a file exists; the default asks the filesystem. */
   readonly exists?: (path: string) => boolean;
+  /** The host extensions the prober offers beyond the console's, each one of {@link OMX_CLAP_HOST_CONFIGURED_EXTENSIONS}. */
+  readonly offer?: readonly string[];
 }
 
 /**
@@ -341,6 +396,7 @@ export function qualifyClap(binaryPath: string, id: string | undefined, options:
     String(CLAP_SWEEP_FRAMES),
     "--blocks",
     String(CLAP_SWEEP_BLOCKS),
+    ...(options.offer === undefined || options.offer.length === 0 ? [] : ["--offer", options.offer.join(",")]),
     binaryPath,
     ...(id === undefined ? [] : [id]),
   ];
@@ -364,9 +420,24 @@ export interface ClapQualifyPass {
 }
 
 /**
- * Qualify every CLAP target, one prober run per target (a crash takes only that plugin), and judge
- * each line under every host profile. A target without a binary path (a bare `urn:clap:` id) has
- * nothing to load and is a failure, never a pass.
+ * What the prober must offer beyond the console's extensions to measure for `profile`: the extra
+ * extensions of its list, when the prober can offer each and the list holds the console's; `undefined`
+ * for a profile the prober cannot stand in for (no CLAP path, or an extension it cannot offer), which
+ * is judged from the console's run and reads `unknown` there.
+ */
+export function proberOffer(profile: HostProfile): readonly string[] | undefined {
+  const wanted = profile.clapExtensions;
+  if (wanted === null || !OMX_CLAP_HOST_EXTENSIONS.every((e) => wanted.includes(e))) return undefined;
+  const extra = wanted.filter((e) => !OMX_CLAP_HOST_EXTENSIONS.includes(e));
+  if (!extra.every((e) => OMX_CLAP_HOST_CONFIGURED_EXTENSIONS.includes(e))) return undefined;
+  return OMX_CLAP_HOST_CONFIGURED_EXTENSIONS.filter((e) => extra.includes(e));
+}
+
+/**
+ * Qualify every CLAP target, one prober run per target and set of offered extensions (a crash takes
+ * only that plugin), and judge each line under every host profile, from the run that offered that
+ * profile's extensions. A target without a binary path (a bare `urn:clap:` id) has nothing to load
+ * and is a failure, never a pass.
  */
 export function qualifyClapTargets(
   targets: readonly PluginTarget[],
@@ -378,10 +449,16 @@ export function qualifyClapTargets(
   const failures: { uri: string; problem: string }[] = [];
   for (const target of targets) {
     const id = target.uri.startsWith("urn:clap:") ? target.uri.slice("urn:clap:".length) : undefined;
-    let lines: ClapQualifyLine[];
+    // one run per distinct offer, the console's (none) for a profile the prober cannot stand in for
+    const offers = new Map<string, readonly string[]>();
+    for (const profile of profiles) {
+      const offer = proberOffer(profile) ?? [];
+      offers.set(offer.join(","), offer);
+    }
+    const runs = new Map<string, ClapQualifyLine[]>();
     try {
       if (target.binaryPath === undefined) throw new ClapQualifyError(`${target.uri}: no .clap to load; name the file or a directory holding it`);
-      lines = qualifyClap(target.binaryPath, id, options);
+      for (const [key, offer] of offers) runs.set(key, qualifyClap(target.binaryPath, id, { ...options, offer }));
     } catch (e) {
       if (!(e instanceof ClapQualifyError)) throw e;
       failures.push({ uri: target.uri, problem: e.message });
@@ -390,8 +467,8 @@ export function qualifyClapTargets(
       }
       continue;
     }
-    for (const line of lines) {
-      for (const profile of profiles) {
+    for (const profile of profiles) {
+      for (const line of runs.get((proberOffer(profile) ?? []).join(","))!) {
         const doc = rtSafetyDocument(line, profile);
         documents.push(doc);
         verdicts.push(rtSafetyVerdict(doc));

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',
@@ -72,6 +76,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

@@ -199,12 +199,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 +213,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",
   },
 ];
 
@@ -342,6 +342,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. */
@@ -888,6 +910,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 +958,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 +1041,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

@@ -17,5 +17,6 @@ export * from "./clap-loader.js";
 export * from "./clap-qualify.js";
 export * from "./qualify-options.js";
 export * from "./qualify-cli.js";
+export * from "./pins-file.js";
 export * from "./measure-host.js";
 export * from "./cost-fields.js";

package/src/lv2-loader.ts

@@ -9,8 +9,9 @@
  * 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.
  */
-import { existsSync, readFileSync, statSync } from "node:fs";
-import { basename, join } from "node:path";
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, join, resolve } from "node:path";
 
 import type { PluginLoader, PluginTarget } from "./loader.js";
 
@@ -48,3 +49,28 @@ export const lv2Loader: PluginLoader = {
     return URI_SHAPE.test(target) ? [{ format: "lv2", uri: target }] : undefined;
   },
 };
+
+/** lilv's default LV2 search path, used when `LV2_PATH` is unset. */
+const LV2_DEFAULT_DIRS = [".lv2", "/usr/lib/lv2", "/usr/lib64/lv2", "/usr/local/lib/lv2", "/usr/local/lib64/lv2"];
+
+/**
+ * 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.
+ */
+export function lv2BundlesOnPath(env: Readonly<Record<string, string | undefined>>, home: string = homedir()): string[] {
+  const named = (env["LV2_PATH"] ?? "").split(":").filter((d) => d !== "");
+  const dirs = named.length > 0 ? named : LV2_DEFAULT_DIRS.map((d) => (d.startsWith("/") ? d : join(home, d)));
+  const bundles: string[] = [];
+  for (const dir of new Set(dirs.map((d) => resolve(d)))) {
+    let names: string[];
+    try {
+      names = readdirSync(dir);
+    } catch (e) {
+      const code = (e as NodeJS.ErrnoException).code;
+      if (code === "ENOENT" || code === "ENOTDIR") continue;
+      throw e;
+    }
+    for (const n of names.sort()) if (n.endsWith(".lv2")) bundles.push(join(dir, n));
+  }
+  return bundles;
+}

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

@@ -79,8 +79,22 @@ export interface MeasureOptions {
   readonly run: boolean;
   /** Print the plan and probe nothing. */
   readonly dryRun: boolean;
+  /**
+   * The LV2 measurer's feature-option flags (`--features`, `--strict`, ...), in the order given, passed
+   * to every run of the hosting pass. Absent or empty: the measurer's defaults.
+   */
+  readonly featureFlags?: readonly string[];
 }
 
+/**
+ * The words the LV2 measurer's feature-option flags take, as `native/lv2-measure-options.c` names
+ * them: the provider's kinds (`--features`), its buf-size declarations (`--block-declares`) and its log
+ * modes (`--log`). A conformance test reads both.
+ */
+export const LV2_FEATURE_KINDS = ["map", "unmap", "options", "bounded", "worker", "default-state", "log"] as const;
+export const LV2_BLOCK_DECLARATIONS = ["bounded", "fixed", "pow2"] as const;
+export const LV2_LOG_MODES = ["silent", "route", "capture"] as const;
+
 /** One subprocess the pipeline runs, and what it leaves behind. */
 export interface PipelineStep {
   /** Stable id: `scan` / `latency-declared` / `latency-measured` / `cost` / `hosting`. */
@@ -205,6 +219,7 @@ export function buildPipeline(options: MeasureOptions, native?: HostingTools): P
         String(LV2_HOSTING_BLOCK_FRAMES),
         String(LV2_HOSTING_LIFECYCLES),
         String(LV2_HOSTING_REPEATS),
+        ...(options.featureFlags ?? []),
       ],
       perPlugin: true,
       env: { LD_PRELOAD: native.interposer, OMX_STIM: "noise" },
@@ -287,6 +302,32 @@ function parseRates(text: string): number[] | undefined {
 /** What `--dimensions` takes: the prober's, and the hosting pass's. */
 export const MEASURED_DIMENSIONS: readonly MeasurementDimension[] = [...PROBED_DIMENSIONS, ...HOSTING_PASS_DIMENSIONS];
 
+/** Whether `text` is a comma-separated list of `words` (empty: none of them). */
+function wordList(text: string, words: readonly string[]): boolean {
+  return text === "" || text.split(",").every((w) => words.includes(w));
+}
+
+/** A block length or a buffer size: a whole number of at least `min`. */
+function wholeNumber(text: string, min: number): boolean {
+  return /^\d+$/.test(text) && Number(text) >= min && Number(text) <= 2 ** 31 - 1;
+}
+
+/**
+ * What each feature-option flag takes: a check of its value, or `undefined` for a switch. The
+ * measurer checks the values again; these refuse a bad one before any plugin is run.
+ */
+const FEATURE_FLAGS: Readonly<Record<string, ((value: string) => boolean) | undefined>> = {
+  "--features": (v) => wordList(v, LV2_FEATURE_KINDS),
+  "--block-declares": (v) => wordList(v, LV2_BLOCK_DECLARATIONS),
+  "--block-min": (v) => wholeNumber(v, 0),
+  "--block-max": (v) => wholeNumber(v, 0),
+  "--block-nominal": (v) => wholeNumber(v, 0),
+  "--log": (v) => (LV2_LOG_MODES as readonly string[]).includes(v),
+  "--log-capture-bytes": (v) => wholeNumber(v, 2),
+  "--strict": undefined,
+  "--no-strict": undefined,
+};
+
 function parseDimensions(text: string): MeasurementDimension[] | undefined {
   const wanted = text.split(",").map((part) => part.trim());
   const dimensions = MEASURED_DIMENSIONS.filter((d) => wanted.includes(d));
@@ -320,6 +361,7 @@ export function parseMeasureArgs(
   let python = env.PYTHON ?? "python3";
   let run = env.LV2_MEASURE_RUN === "1";
   let dryRun = false;
+  const featureFlags: string[] = [];
 
   for (let i = 0; i < argv.length; i += 1) {
     const flag = argv[i];
@@ -403,8 +445,19 @@ export function parseMeasureArgs(
       case "--dry-run":
         dryRun = true;
         break;
-      default:
-        return { ok: false, error: `unknown argument: ${String(flag)}` };
+      default: {
+        if (flag === undefined || !Object.hasOwn(FEATURE_FLAGS, flag)) {
+          return { ok: false, error: `unknown argument: ${String(flag)}` };
+        }
+        const check = FEATURE_FLAGS[flag];
+        if (check === undefined) {
+          featureFlags.push(flag);
+          break;
+        }
+        const value = next();
+        if (value === undefined || !check(value)) return { ok: false, error: `${flag}: ${featureFlagUse(flag)}` };
+        featureFlags.push(flag, value);
+      }
     }
   }
 
@@ -414,6 +467,12 @@ export function parseMeasureArgs(
       error: "--rates is required: a measurement with no stated rate is not a measurement",
     };
   }
+  if (featureFlags.length > 0 && !dimensions.some((d) => (HOSTING_PASS_DIMENSIONS as readonly string[]).includes(d))) {
+    return {
+      ok: false,
+      error: `the feature options are the hosting pass's: ${featureFlags[0]} needs one of ${HOSTING_PASS_DIMENSIONS.join(",")}`,
+    };
+  }
   if (plugins !== undefined && dimensions.some((d) => (PROBED_DIMENSIONS as readonly string[]).includes(d))) {
     return {
       ok: false,
@@ -436,10 +495,26 @@ export function parseMeasureArgs(
       ...(plugins === undefined ? {} : { plugins }),
       ...(costCpu === undefined ? {} : { costCpu }),
       ...(label === undefined ? {} : { label }),
+      ...(featureFlags.length === 0 ? {} : { featureFlags }),
     },
   };
 }
 
+function featureFlagUse(flag: string): string {
+  switch (flag) {
+    case "--features":
+      return `a comma-separated list of ${LV2_FEATURE_KINDS.join(",")} (empty: none)`;
+    case "--block-declares":
+      return `a comma-separated list of ${LV2_BLOCK_DECLARATIONS.join(",")} (empty: none)`;
+    case "--log":
+      return `one of ${LV2_LOG_MODES.join(", ")}`;
+    case "--log-capture-bytes":
+      return "a size in bytes of at least 2";
+    default:
+      return "a number of frames, 0 for the run's block";
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Progress
 // ---------------------------------------------------------------------------

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/vocabulary.ts

@@ -302,7 +302,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];