@openmixer/plugin-qualify 0.11.0 → 0.12.0

package/src/measurement/cli.ts

@@ -54,6 +54,9 @@ export const TOOL_NAME = "lv2-measure";
  */
 export const TOOL_VERSION = "0.1.0";
 
+/** The most notes a cost run holds: one per MIDI key, as the probers cap it. */
+export const PROBE_NOTES_MAX = 128;
+
 /** A fully resolved invocation. */
 export interface MeasureOptions {
   /** Where the document goes. Absent = stdout. */
@@ -70,6 +73,11 @@ export interface MeasureOptions {
   readonly sweep: boolean;
   /** Core to pin the cost pass to. Absent = let the prober choose. */
   readonly costCpu?: number;
+  /**
+   * The notes the cost pass holds down while it times an instrument (`--probe-notes`, the console's
+   * `SYNTH_VOICE_PROBE_NOTES`), basis `probe`. Absent = an instrument is unmeasured `voices-unknown`.
+   */
+  readonly probeNotes?: number;
   readonly label?: string;
   /** Directory holding `scan.py` and `benchmark.py`. */
   readonly toolDir: string;
@@ -203,6 +211,7 @@ export function buildPipeline(options: MeasureOptions, native?: HostingTools): P
         "--cost-provenance",
         costProvenance,
         ...(options.costCpu === undefined ? [] : ["--cost-cpu", String(options.costCpu)]),
+        ...(options.probeNotes === undefined ? [] : ["--probe-notes", String(options.probeNotes)]),
       ],
       produces: cost,
       dimension: "cost",
@@ -356,6 +365,7 @@ export function parseMeasureArgs(
   let workDir = defaults.workDir;
   let sweep = false;
   let costCpu: number | undefined;
+  let probeNotes: number | undefined;
   let label: string | undefined;
   let toolDir = defaults.toolDir;
   let python = env.PYTHON ?? "python3";
@@ -430,6 +440,15 @@ export function parseMeasureArgs(
         costCpu = cpu;
         break;
       }
+      case "--probe-notes": {
+        const value = next();
+        const notes = value === undefined ? Number.NaN : Number(value);
+        if (!Number.isInteger(notes) || notes < 1 || notes > PROBE_NOTES_MAX) {
+          return { ok: false, error: `--probe-notes needs a count of notes, 1 to ${PROBE_NOTES_MAX}` };
+        }
+        probeNotes = notes;
+        break;
+      }
       case "--label": {
         const value = next();
         if (value === undefined) return { ok: false, error: "--label needs text" };
@@ -494,6 +513,7 @@ export function parseMeasureArgs(
       ...(scanPath === undefined ? {} : { scanPath }),
       ...(plugins === undefined ? {} : { plugins }),
       ...(costCpu === undefined ? {} : { costCpu }),
+      ...(probeNotes === undefined ? {} : { probeNotes }),
       ...(label === undefined ? {} : { label }),
       ...(featureFlags.length === 0 ? {} : { featureFlags }),
     },

package/src/measurement/format.ts

@@ -58,10 +58,12 @@ import {
   type HostLatencyHandling,
   type MeasurementDimension,
   type VerdictRating,
+  type VoiceBasis,
   HOST_ISOLATIONS,
   HOST_LATENCY_HANDLING,
   MEASUREMENT_DIMENSIONS,
   VERDICT_RATINGS,
+  isVoiceBasis,
   readDimension,
 } from "./vocabulary.js";
 
@@ -74,8 +76,10 @@ export const MEASUREMENT_FORMAT_MAJOR = 1;
 /** The minor this build writes. Additive-only within {@link MEASUREMENT_FORMAT_MAJOR}.
  *  `1.1` added the three hosting dimensions — {@link StabilityMeasurement},
  *  {@link RtSafetyMeasurement}, {@link FeaturesMeasurement} — which a 1.0 reader skips.
- *  `1.2` added the verdicts per host profile; `1.3` the {@link IntegrityMeasurement} block. */
-export const MEASUREMENT_FORMAT_MINOR = 3;
+ *  `1.2` added the verdicts per host profile; `1.3` the {@link IntegrityMeasurement} block; `1.4` the notes
+ *  an instrument's cost was measured with ({@link CostAtRate.voices}); `1.5` the note sweep an instrument's
+ *  `run()` was counted under ({@link RtSafetyMeasurement.noteSweep}). */
+export const MEASUREMENT_FORMAT_MINOR = 5;
 
 /** The version string this build writes, e.g. `"1.0"`. */
 export const MEASUREMENT_FORMAT_VERSION = `${MEASUREMENT_FORMAT_MAJOR}.${MEASUREMENT_FORMAT_MINOR}`;
@@ -270,6 +274,17 @@ export interface LatencyMeasurement {
   readonly unmeasuredDetail?: string;
 }
 
+/**
+ * The notes an instrument held down while its cost was timed (1.4): how many, where that count came
+ * from ({@link VoiceBasis}), and the voice capacity the plugin declared at that rate when it declares one.
+ * An instrument costs nothing until a voice plays, so its figure means nothing without this.
+ */
+export interface VoicesHeld {
+  readonly held: number;
+  readonly basis: VoiceBasis;
+  readonly capacity?: number;
+}
+
 /** One rate's cost reading. Per SAMPLE, so it is independent of the block size. */
 export interface CostAtRate {
   readonly nsPerSampleMedian: number;
@@ -286,6 +301,8 @@ export interface CostAtRate {
   /** Timed, but emitted silence under a stimulus that should have passed — the figure may
    *  describe a short-circuit path rather than the DSP. */
   readonly silentOutput?: boolean;
+  /** 1.4: for an instrument, the notes held while it was timed. Absent for an effect. */
+  readonly voices?: VoicesHeld;
 }
 
 /** Everything one run learned about one plugin's CPU cost. */
@@ -369,6 +386,27 @@ export interface StabilityMeasurement {
   readonly unmeasuredDetail?: string;
 }
 
+/**
+ * 1.5: an instrument played through its MIDI input while the interposer counted, apart from the control
+ * sweep — a chord, bend and a controller, pressure, the chord let go, a burst of note ons and their offs,
+ * all notes off. `applicable: false` is a plugin with no MIDI input; the counts are present only when
+ * the interposer was loaded.
+ */
+export interface NoteSweepMeasurement {
+  readonly applicable: boolean;
+  readonly dialect?: "clap" | "midi";
+  readonly blocks?: number;
+  readonly blockFrames?: number;
+  /** The 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 an interposer counted INSIDE `run()`. `rate` and `blockFrames` are the pair it ran at —
  * a count is a property of the code paths the run took there. Readable when all three counts
@@ -391,6 +429,8 @@ export interface RtSafetyMeasurement {
   readonly syscallsInRun?: number;
   /** Repeats disagreed. */
   readonly variable?: boolean;
+  /** 1.5: the same counts taken while the plugin was played through its MIDI input. */
+  readonly noteSweep?: NoteSweepMeasurement;
   readonly unmeasuredReason?: string;
   readonly unmeasuredDetail?: string;
 }
@@ -834,9 +874,20 @@ function readCostAtRate(value: unknown): CostAtRate | undefined {
     ...optional("nsPerSampleMax", finiteNumber(value.nsPerSampleMax)),
     ...optional("warmupNsPerSampleMedian", finiteNumber(value.warmupNsPerSampleMedian)),
     ...optional("silentOutput", booleanValue(value.silentOutput)),
+    ...optional("voices", readVoicesHeld(value.voices)),
   };
 }
 
+/** The notes held, or `undefined` unless the count and a known basis are there. */
+export function readVoicesHeld(value: unknown): VoicesHeld | undefined {
+  if (!isRecord(value)) return undefined;
+  const held = positiveNumber(value.held);
+  const basis = isVoiceBasis(value.basis) ? value.basis : undefined;
+  const capacity = finiteNumber(value.capacity);
+  if (held === undefined || !Number.isInteger(held) || basis === undefined) return undefined;
+  return { held, basis, ...(capacity !== undefined && Number.isInteger(capacity) && capacity >= 0 ? { capacity } : {}) };
+}
+
 function readCost(value: unknown): CostMeasurement | undefined {
   if (!isRecord(value)) return undefined;
   return {
@@ -942,10 +993,37 @@ function readRtSafety(value: unknown): RtSafetyMeasurement | undefined {
     ...optional("locksInRun", finiteNumber(value.locksInRun)),
     ...optional("syscallsInRun", finiteNumber(value.syscallsInRun)),
     ...optional("variable", booleanValue(value.variable)),
+    ...optional("noteSweep", readNoteSweep(value.noteSweep)),
     ...reasonOf(value),
   };
 }
 
+/** A note sweep, or `undefined` unless it says whether it was applicable; a count it cannot vouch for is left out. */
+export function readNoteSweep(value: unknown): NoteSweepMeasurement | undefined {
+  if (!isRecord(value)) return undefined;
+  const applicable = booleanValue(value.applicable);
+  if (applicable === undefined) return undefined;
+  if (!applicable) return { applicable };
+  const dialect = value.dialect === "clap" || value.dialect === "midi" ? value.dialect : undefined;
+  const counted = (v: unknown) => {
+    const n = finiteNumber(v);
+    return n !== undefined && Number.isInteger(n) && n >= 0 ? n : undefined;
+  };
+  return {
+    applicable,
+    ...optional("dialect", dialect),
+    ...optional("blocks", counted(value.blocks)),
+    ...optional("blockFrames", counted(value.blockFrames)),
+    ...optional("noteEvents", counted(value.noteEvents)),
+    ...optional("processErrors", counted(value.processErrors)),
+    ...optional("nonFinite", booleanValue(value.nonFinite)),
+    ...optional("interposer", booleanValue(value.interposer)),
+    ...optional("allocationsInRun", counted(value.allocationsInRun)),
+    ...optional("locksInRun", counted(value.locksInRun)),
+    ...optional("syscallsInRun", counted(value.syscallsInRun)),
+  };
+}
+
 function readFeatures(value: unknown): FeaturesMeasurement | undefined {
   if (!isRecord(value)) return undefined;
   return {

package/src/measurement/probe-json.ts

@@ -35,6 +35,7 @@ import type {
   PluginTopology,
 } from "./format.js";
 import { booleanValue, finiteNumber, isRecord, nonEmptyString, optional, positiveNumber } from "./guards.js";
+import { readVoicesHeld } from "./format.js";
 import type { MeasurementDimension } from "./vocabulary.js";
 
 /** One free-text prober failure, and the vocabulary term it means. */
@@ -55,6 +56,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: /^voices-unknown$/, code: "voices-unknown" },
   { match: /hosting\.worker\.nonconforming/, code: "worker-nonconforming" },
   { match: /worker crashed|worker desync|worker unavailable/, code: "probe-crashed" },
   { match: /timed out|timeout/, code: "probe-timeout" },
@@ -198,6 +200,7 @@ function readCost(value: unknown): CostMeasurement | undefined {
         ...optional("nsPerSampleMax", finiteNumber(reading.nsPerSampleMax)),
         ...optional("warmupNsPerSampleMedian", finiteNumber(reading.warmupNsPerSampleMedian)),
         ...optional("silentOutput", booleanValue(reading.silentOutput)),
+        ...optional("voices", readVoicesHeld(reading.voices)),
       };
     }
   }

package/src/measurement/sweep-jsonl.ts

@@ -29,7 +29,7 @@ import type {
   SoakReading,
   StabilityMeasurement,
 } from "./format.js";
-import { readIntegrity, readLifecycle, readSoakAtRate, readThreads } from "./format.js";
+import { readIntegrity, readLifecycle, readNoteSweep, readSoakAtRate, readThreads } from "./format.js";
 import { booleanValue, finiteNumber, isRecord, mapArray, nonEmptyString, optional, positiveNumber } from "./guards.js";
 
 /** The sweep's three passes, each a list of parsed JSONL lines. Only `measurements` is required. */
@@ -106,6 +106,7 @@ function rtSafetyOf(row: Record<string, unknown>): RtSafetyMeasurement {
     ...optional("locksInRun", finiteNumber(rt.locksInRun)),
     ...optional("syscallsInRun", finiteNumber(rt.syscallsInRun)),
     ...optional("variable", booleanValue(rt.variable)),
+    ...optional("noteSweep", readNoteSweep(rt.noteSweep)),
   };
 }
 

package/src/measurement/vocabulary.ts

@@ -85,6 +85,25 @@ export const UNMEASURED_TERMS: readonly UnmeasuredTerm[] = [
       "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.",
   },
+  {
+    code: "no-voices",
+    kind: "nothing-to-measure",
+    description:
+      "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.",
+  },
+  {
+    code: "notes-unplayable",
+    kind: "nothing-to-measure",
+    description: "An instrument whose note input reads no dialect the prober speaks (CLAP's or MIDI's): it cannot be played.",
+  },
+  {
+    code: "voices-unknown",
+    kind: "not-attempted",
+    description:
+      "An instrument that declares no voice capacity, measured by a run given no probe count (`--probe-notes`): " +
+      "the run did not know how many notes to hold, so it timed none.",
+  },
   {
     code: "refused-instantiation",
     kind: "probe-failed",
@@ -317,3 +336,15 @@ export type HostIsolation = (typeof HOST_ISOLATIONS)[number];
 export const HOST_LATENCY_HANDLING = ["compensated", "uncompensated"] as const;
 export type HostLatencyHandling = (typeof HOST_LATENCY_HANDLING)[number];
 
+/**
+ * Where the number of notes an instrument's cost was measured with came from: `declared` is the voice
+ * capacity the plugin declares (CLAP's voice-info, read after activate at that rate); `probe` is a count
+ * the caller gave (`--probe-notes`, the console's `SYNTH_VOICE_PROBE_NOTES`), used when the plugin declares
+ * none or when the caller asked for that count whatever it declares.
+ */
+export const VOICE_BASES = ["declared", "probe"] as const;
+export type VoiceBasis = (typeof VOICE_BASES)[number];
+
+export function isVoiceBasis(value: unknown): value is VoiceBasis {
+  return VOICE_BASES.some((b) => b === value);
+}

package/src/probe-judge.ts

@@ -27,6 +27,7 @@ import {
 import { gridCostReadings } from "./cost-fields.js";
 import {
   hostingCostReasons,
+  noteSweepReasons,
   rtSafetyReasons,
   contributedHostingRating,
   type HostingReason,
@@ -35,7 +36,7 @@ import type { HostProfile } from "./host-profiles.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";
-import type { IntegrityMeasurement } from "./measurement/format.js";
+import type { IntegrityMeasurement, VoicesHeld } from "./measurement/format.js";
 
 /** Facts of the descriptor, which the probe output repeats none of. */
 export interface JudgeFacts {
@@ -168,8 +169,11 @@ export interface HostJudgment {
   /** 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";
   readonly reasons: readonly RecordReason[];
-  /** The cost reasons at this host's rate and quantum, kept beside the verdict, not folded into it. */
-  readonly cost: { readonly rate: number; readonly quantum: number; 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,
+   * the notes it held while that figure was timed.
+   */
+  readonly cost: { readonly rate: number; readonly quantum: number; readonly voices?: VoicesHeld; readonly reasons: readonly RecordReason[] };
 }
 
 export interface Judgment {
@@ -191,7 +195,8 @@ function costOf(output: ProbeOutput, profile: HostProfile): HostJudgment["cost"]
     { rate, quantum, profile },
     DEFAULT_HOSTING_POLICY,
   );
-  return { rate, quantum, reasons: reasons.map(asRecordReason) };
+  const voices = output.grid.find((p) => p.outcome === PROBE_OK && p.rate === rate && p.quantum === quantum)?.cost?.voices;
+  return { rate, quantum, ...(voices === undefined ? {} : { voices }), reasons: reasons.map(asRecordReason) };
 }
 
 /**
@@ -237,7 +242,10 @@ export function judgeProbeOutput(output: ProbeOutput, profiles: readonly HostPro
       documents.push(doc);
       reasons = doc.verdict.reasons.map(asRecordReason);
     } else {
-      reasons = rtSafetyReasons(rtSafetyOfProbeOutput(output)).map(asRecordReason);
+      // an LV2 plugin: the control sweep's counts, and the note sweep's when it was played through a MIDI input
+      const rt = rtSafetyOfProbeOutput(output);
+      const notes = noteSweepOfProbeOutput(output, rt);
+      reasons = [...rtSafetyReasons(rt), ...noteSweepReasons(notes, facts.noteInputs ?? (notes.applicable ? 1 : 0))].map(asRecordReason);
     }
     const rating = worstRating(reasons.map((r) => r.rating));
     const deciding = decidingOf(reasons, rating);

package/src/probe-output.ts

@@ -20,6 +20,7 @@
 import { createHash } from "node:crypto";
 
 import { finiteNumber, isRecord, nonEmptyString, optional } from "./measurement/guards.js";
+import { readVoicesHeld, type VoicesHeld } from "./measurement/format.js";
 
 export const PROBE_OUTPUT_FORMAT = "plugin-hostd.probe-output";
 /** The one major this reader knows. A minor of it only adds fields. */
@@ -60,6 +61,8 @@ export interface ProbeCost {
   readonly percentile: { readonly p: number; readonly value: number };
   readonly blocks: number;
   readonly warmupBlocks: number;
+  /** For an instrument: the notes it held while it was timed, how many and why that many. */
+  readonly voices?: VoicesHeld;
 }
 
 export interface ProbeRtSafety {
@@ -240,11 +243,14 @@ function readCost(v: unknown, where: string): ProbeCost {
   const median = num(o, "median", where);
   const value = num(pct, "value", `${where} percentile`);
   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`);
   return {
     median,
     percentile: { p, value },
     blocks: posInt(o, "blocks", where),
     warmupBlocks: count(o, "warmupBlocks", where),
+    ...(voices === undefined ? {} : { voices }),
   };
 }
 

package/src/qualification-record.ts

@@ -18,6 +18,7 @@ import { join } from "node:path";
 
 import type { Judgment, RecordReason } from "./probe-judge.js";
 import { sha256Hex, type ProbeGridPoint, type ProbeOutput } from "./probe-output.js";
+import type { VoicesHeld } from "./measurement/format.js";
 
 export const QUALIFICATION_RECORD_SCHEMA = "plugin-qualify.qualification-record/1";
 
@@ -41,8 +42,14 @@ export interface QualificationRecord {
   readonly testedVersion?: string;
   readonly binary: ProbeOutput["binary"];
   readonly verdicts: readonly RecordVerdict[];
-  /** The cost reasons at each host's rate and quantum, beside the verdicts. */
-  readonly cost: readonly { readonly host: string; readonly rate: number; readonly quantum: number; readonly reasons: readonly RecordReason[] }[];
+  /** The cost reasons at each host's rate and quantum, beside the verdicts; an instrument's with the notes it held. */
+  readonly cost: readonly {
+    readonly host: string;
+    readonly rate: number;
+    readonly quantum: number;
+    readonly voices?: VoicesHeld;
+    readonly reasons: readonly RecordReason[];
+  }[];
   /** The figures as measured, per rate and quantum. */
   readonly measurements: { readonly grid: readonly ProbeGridPoint[]; readonly behaviour?: Readonly<Record<string, unknown>> };
   /** Who measured and when. */

package/tools/benchmark.py

@@ -179,6 +179,14 @@ COST_PERCENTILE = 95.0
 DEFAULT_COST_TIMEOUT = float(COST_TIMEOUT_S)
 # Iterations of the empty-call loop that measures the harness's own timing floor.
 COST_CALIBRATION_ITERS = 512
+# An instrument (a MIDI input, and no audio input or the lv2:InstrumentPlugin class) is timed
+# holding notes down, since it costs nothing until a voice plays: `--probe-notes` notes, struck at
+# velocity 127 in the first block and never let go, spread across a piano's keys (every MIDI key
+# past 88). LV2 declares no voice capacity, so the count is always the caller's: basis `probe`. The
+# same rule as the CLAP prober's cost arm (`native/clap-qualify.c`, `held_key`).
+NOTE_KEYS_MAX = 128
+PIANO_LOW_KEY, PIANO_HIGH_KEY, PIANO_KEYS = 21, 108, 88
+HELD_VELOCITY = 127
 
 # What measure_offline returns: measured latencies, the plugins that failed (each
 # with a human reason) so one finicky plugin never silently drops the batch,
@@ -858,6 +866,32 @@ def instances_per_core(fraction):
     return int(1.0 / float(fraction))
 
 
+def held_keys(n):
+    """The `n` keys an instrument's cost holds down: spread evenly across a piano's keys, or every
+    MIDI key past 88 notes; one note is A4. Pure, and the CLAP prober's `held_key` rule."""
+    n = int(n)
+    if n <= 1:
+        return [69] if n == 1 else []
+    low, high = (PIANO_LOW_KEY, PIANO_HIGH_KEY) if n <= PIANO_KEYS else (0, NOTE_KEYS_MAX - 1)
+    return [low + i * (high - low) // (n - 1) for i in range(n)]
+
+
+def midi_sequence(events, seq_urid, midi_urid):
+    """An LV2 atom:Sequence holding `events`, each `(frame, bytes)` of one MIDI message, as the
+    little-endian bytes a host writes into an atom input port. Pure.
+
+    The layout is the atom spec's: the sequence atom (size, type), its body (unit 0 = frames, pad),
+    then per event its time (int64 frames), the event atom (size, type) and the message padded to 8.
+    """
+    import struct
+
+    body = struct.pack("<II", 0, 0)
+    for frame, data in events:
+        msg = bytes(data)
+        body += struct.pack("<qII", int(frame), len(msg), midi_urid) + msg + b"\0" * (-len(msg) % 8)
+    return struct.pack("<II", len(body), seq_urid) + body
+
+
 def summarise_cost(block_times_ns, block_frames, rate, warmup=DEFAULT_COST_WARMUP,
                    pct=COST_PERCENTILE):
     """Fold per-block wall times into one rate's cost record. Pure.
@@ -1081,6 +1115,7 @@ def annotate_measured(catalog, measured, unmeasurable, sample_rate, tol=2):
 
 LV2 = "http://lv2plug.in/ns/lv2core#"
 ATOM = "http://lv2plug.in/ns/ext/atom#"
+MIDI_EVENT = "http://lv2plug.in/ns/ext/midi#MidiEvent"
 URID = "http://lv2plug.in/ns/ext/urid#"
 OPTIONS = "http://lv2plug.in/ns/ext/options#"
 BUFSZ = "http://lv2plug.in/ns/ext/buf-size#"
@@ -1383,6 +1418,23 @@ def audio_port_indices(host, plugin):
     return audio_in, audio_out
 
 
+def is_instrument_class(host, plugin):
+    """True when the plugin's class is lv2:InstrumentPlugin."""
+    cls = plugin.get_class()
+    return cls is not None and str(cls.get_uri()) == LV2 + "InstrumentPlugin"
+
+
+def midi_input_index(host, plugin):
+    """The index of the plugin's first atom input that takes MIDI events, or None."""
+    midi = host.world.new_uri(MIDI_EVENT)
+    for i in range(plugin.get_num_ports()):
+        port = plugin.get_port_by_index(i)
+        if (port.is_a(host.u[ATOM + "AtomPort"]) and port.is_a(host.u[LV2 + "InputPort"])
+                and port.supports_event(midi)):
+            return i
+    return None
+
+
 def instantiate_connected(host, plugin, overrides=None):
     """Instantiate `plugin` and connect a live buffer to every one of its ports.
 
@@ -1589,7 +1641,7 @@ def timing_floor_ns(iters=COST_CALIBRATION_ITERS):
 
 
 def cost_one(host, uri, warmup=DEFAULT_COST_WARMUP, max_blocks=DEFAULT_COST_BLOCKS,
-             min_blocks=COST_MIN_BLOCKS, target_seconds=COST_TARGET_SECONDS):
+             min_blocks=COST_MIN_BLOCKS, target_seconds=COST_TARGET_SECONDS, probe_notes=None):
     """Instantiate one plugin offline and MEASURE its CPU cost per processed sample.
 
     A sustained 1 kHz sine at -6 dBFS is held on every audio input, phase-continuous
@@ -1601,13 +1653,18 @@ def cost_one(host, uri, warmup=DEFAULT_COST_WARMUP, max_blocks=DEFAULT_COST_BLOC
     the gap between them is the xrun risk. Signal, not silence: a plugin that
     short-circuits on a silent input would otherwise be recorded as free.
 
+    An instrument (a MIDI atom input, and no audio input or the lv2:InstrumentPlugin class) also
+    holds `probe_notes` notes down ({@link held_keys}, velocity 127), struck in the first block and
+    never let go, and the record says so (`voices: {held, basis: "probe"}`). Without a count it is
+    not timed. A synth's audio input (synthv1 has one) hears the tone like any other.
+
     Buffer filling and every statistic are outside the timed region; the GC is off
     across the loop, so a collection cannot land inside a block and be charged to
     the plugin.
 
     Returns exactly one of:
-      {"blockTimesNs": [...], "silentOutput": bool}   timings, warm-up head first
-      {"unmeasurable": <reason>}   no audio in/out — nothing to insert, nothing to cost
+      {"blockTimesNs": [...], "silentOutput": bool[, "voices": {...}]}   timings, warm-up head first
+      {"unmeasurable": <reason>}   no audio in/out, or an instrument with no count to hold
       {"error": <reason>}          not installed / refused / non-finite output
     """
     import gc
@@ -1618,14 +1675,26 @@ def cost_one(host, uri, warmup=DEFAULT_COST_WARMUP, max_blocks=DEFAULT_COST_BLOC
     if plugin is None:
         return {"error": "not installed"}
     audio_in, audio_out = audio_port_indices(host, plugin)
-    if not audio_in:
+    midi_in = midi_input_index(host, plugin)
+    if midi_in is not None and audio_in and not is_instrument_class(host, plugin):
+        midi_in = None  # an effect that also takes MIDI: timed on the tone alone
+    if not audio_in and midi_in is None:
         return {"unmeasurable": "no-audio-in"}
     if not audio_out:
         return {"unmeasurable": "no-audio-out"}
+    if midi_in is not None and not probe_notes:
+        return {"unmeasurable": "voices-unknown"}
+    held = held_keys(min(int(probe_notes), NOTE_KEYS_MAX)) if midi_in is not None else []
 
     instance, buffers, reason = instantiate_connected(host, plugin)
     if instance is None:
         return {"error": reason}
+    atoms = [(i, buf, buf[0]) for i, buf in buffers.items() if buf.dtype == np.uint32]
+    struck = empty = None
+    if midi_in is not None:
+        seq, midi = host.seq_urid, host.map_uri(MIDI_EVENT)
+        struck = np.frombuffer(midi_sequence([(0, (0x90, k, HELD_VELOCITY)) for k in held], seq, midi), dtype=np.uint32)
+        empty = np.frombuffer(midi_sequence([], seq, midi), dtype=np.uint32)
 
     block = host.block
     ins = [buffers[i] for i in audio_in]
@@ -1636,7 +1705,13 @@ def cost_one(host, uri, warmup=DEFAULT_COST_WARMUP, max_blocks=DEFAULT_COST_BLOC
     ramp = np.arange(block, dtype=np.float32)
 
     def drive(blk):
-        """Hold the tone on every audio input for block `blk`. Never timed."""
+        """Hold the tone on every audio input for block `blk`; for an instrument, strike the held notes
+        in the first block and send none after; every atom port a fresh sequence. Never timed."""
+        for _i, buf, size in atoms:
+            buf[0] = size
+        if midi_in is not None:
+            notes = struck if blk == 0 else empty
+            buffers[midi_in][:len(notes)] = notes
         sig = COST_TONE_AMP * np.sin(phase * (blk * block + ramp))
         for buf in ins:
             buf[:] = sig
@@ -1679,9 +1754,12 @@ def cost_one(host, uri, warmup=DEFAULT_COST_WARMUP, max_blocks=DEFAULT_COST_BLOC
 
     if not np.all(np.isfinite(out_buf)):
         return {"error": "non-finite output"}
-    return {"blockTimesNs": times,
-            "silentOutput": bool(np.max(np.abs(out_buf)) == 0.0),
-            "worker": host.worker.stats()}
+    res = {"blockTimesNs": times,
+           "silentOutput": bool(np.max(np.abs(out_buf)) == 0.0),
+           "worker": host.worker.stats()}
+    if midi_in is not None:
+        res["voices"] = {"held": len(held), "basis": "probe"}
+    return res
 
 
 def control_ranges(host, plugin, symbols):
@@ -1753,7 +1831,7 @@ def threshold_overrides(host, plugin):
 
 
 def worker_main(rate, block, measure=False, cost=False, cpu=None,
-                warmup=DEFAULT_COST_WARMUP, blocks=DEFAULT_COST_BLOCKS):
+                warmup=DEFAULT_COST_WARMUP, blocks=DEFAULT_COST_BLOCKS, probe_notes=None):
     """The worker loop: JSON-lines protocol over stdio (see parse_worker_line).
 
     Loads the LV2 world once, announces readiness, then probes one plugin per
@@ -1784,7 +1862,7 @@ def worker_main(rate, block, measure=False, cost=False, cpu=None,
         uri, _tab, arg = line.partition("\t")
         if cost:
             try:
-                res = cost_one(host, uri, warmup=warmup, max_blocks=blocks)
+                res = cost_one(host, uri, warmup=warmup, max_blocks=blocks, probe_notes=probe_notes)
             except Exception as e:  # noqa: BLE001 - report, don't die
                 res = {"error": f"cost error: {e}"}
             if "blockTimesNs" in res:
@@ -1796,6 +1874,8 @@ def worker_main(rate, block, measure=False, cost=False, cpu=None,
                     continue
                 if res.get("silentOutput"):
                     record["silentOutput"] = True
+                if "voices" in res:
+                    record["voices"] = res["voices"]
                 # what the host did with the plugin's worker, so a cost read can be told apart
                 # from an unbuilt plugin's (jobs and dropped are counts, never a verdict).
                 if "worker" in res:
@@ -2179,13 +2259,15 @@ def host_provenance(cpu, rates, block, warmup, blocks, timing_floor_ns_value=Non
     }
 
 
-def default_cost_worker_cmd(rate, block, cpu, warmup, blocks):
+def default_cost_worker_cmd(rate, block, cpu, warmup, blocks, probe_notes=None):
     """This same script, in --worker --cost mode, under the same interpreter."""
     cmd = [sys.executable, os.path.abspath(__file__), "--worker", "--cost",
            "--rate", str(rate), "--block", str(block),
            "--cost-warmup", str(warmup), "--cost-blocks", str(blocks)]
     if cpu is not None:
         cmd += ["--cost-cpu", str(cpu)]
+    if probe_notes:
+        cmd += ["--probe-notes", str(probe_notes)]
     return cmd
 
 
@@ -2198,7 +2280,8 @@ def cost_at_rate(catalog, rate, args, cpu):
     """
     worker_cmd = (shlex.split(args.worker_cmd) if args.worker_cmd
                   else default_cost_worker_cmd(rate, args.cost_block, cpu,
-                                               args.cost_warmup, args.cost_blocks))
+                                               args.cost_warmup, args.cost_blocks,
+                                               args.probe_notes))
     # a cost probe runs hundreds of blocks where a latency probe runs a handful, so
     # the latency default would time out honest work; an explicit --timeout wins.
     timeout = DEFAULT_COST_TIMEOUT if args.timeout == DEFAULT_TIMEOUT else args.timeout
@@ -2504,6 +2587,11 @@ def main():
     ap.add_argument("--cost-cpu", type=int,
                     help="pin the cost worker to this cpu (default: the last "
                          "performance core this process may use)")
+    ap.add_argument("--probe-notes", type=int,
+                    help="for --cost: the notes an instrument (a MIDI input, no audio "
+                         "input) holds down while it is timed, 1 to "
+                         f"{NOTE_KEYS_MAX}; its record says basis `probe`. Without it "
+                         "an instrument is unmeasurable `voices-unknown`")
     ap.add_argument("--cost-provenance",
                     help="write the run's host/CPU/governor/settings provenance here "
                          "as JSON — the machine the cost figures are only meaningful "
@@ -2522,11 +2610,14 @@ def main():
                          "perRate figures already in the catalog. No probing, no LV2, "
                          "no --run: use it when a classification rule changes.")
     args = ap.parse_args()
+    if args.probe_notes is not None and not 1 <= args.probe_notes <= NOTE_KEYS_MAX:
+        ap.error(f"--probe-notes takes 1 to {NOTE_KEYS_MAX} notes")
 
     if args.worker:
         worker_main(args.rate, args.block if not args.cost else args.cost_block,
                     measure=args.measure, cost=args.cost, cpu=args.cost_cpu,
-                    warmup=args.cost_warmup, blocks=args.cost_blocks)
+                    warmup=args.cost_warmup, blocks=args.cost_blocks,
+                    probe_notes=args.probe_notes)
         return
 
     if not args.inp:

package/tools/lv2-measure.mjs

@@ -80,6 +80,8 @@ const HELP = `${TOOL_NAME} ${TOOL_VERSION} — measure LV2 plugin latency and CP
   --python BIN            Python interpreter (default: $PYTHON or python3).
   --sweep                 Also sweep latency-bearing controls (finds parameter-dependent latency).
   --cost-cpu N            Pin the cost pass to core N.
+  --probe-notes N         The notes an instrument holds down while its cost is timed (1 to 128);
+                          without it an instrument's cost is unmeasured (voices-unknown).
   --label TEXT            A note recorded with the run.
   --run                   Required to probe. Instantiates and runs every plugin.
   --dry-run               Print the plan and probe nothing.