@openmixer/plugin-qualify 0.5.1 → 0.6.0

package/src/hosting-suitability.ts

@@ -306,6 +306,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";
 
 /** One declared rate's latency reading from the CLAP qualifier (CLAP spec §3, latency). */
 export interface ClapLatencyAtRate {
@@ -404,12 +405,25 @@ export function deadAgainstBest(levelDbfs: number, bestDbfs: number, policy: Hos
   return bestDbfs > -Infinity && levelDbfs < bestDbfs - policy.soakDeadDropDb;
 }
 
+/** The classes of soak failure, as the strings `failures` is built from. */
+export type SoakFailureKind = "died" | "non-finite" | "dead" | "mostly-silent" | "startup-blast" | "timed-out";
+
+export interface SoakFailure {
+  readonly rate: number;
+  readonly kind: SoakFailureKind;
+  /** Extra words for the string form, e.g. `20dBFS`. */
+  readonly detail?: string;
+}
+
 /** A soak's reading: what voided it, if anything, and what it proved when nothing did. */
 export interface SoakFindings {
   /** The SHORTEST rate's seconds — a soak proves no more than its weakest rate ran. */
   readonly seconds: number;
-  /** Every rate that voids the soak, as `<why>@<rate>` — `died@`, `non-finite@`, `dead@`, `mostly-silent@`, `startup-blast@`. */
+  /** Every rate that voids the soak, as `<why>@<rate>` — `died@`, `non-finite@`, `dead@`, `mostly-silent@`, `startup-blast@`, `timed-out@`. */
   readonly failures: readonly string[];
+  /** The same failures, structured — what the per-rate verdict reads. `timed-out` is the supervisor's
+   *  cut, a fact about the harness: it voids the soak but is never a failure of the plugin. */
+  readonly failed: readonly SoakFailure[];
   readonly ratesTested: number;
   /** The largest RSS growth across rates, for the record; not judged. */
   readonly rssGrowthKb: number;
@@ -432,35 +446,43 @@ export function soakFindings(soak: SoakReading | undefined, policy: HostingPolic
   if (soak === undefined) return undefined;
   const rates = Object.entries(soak.perRate);
   if (rates.length === 0) return undefined;
-  const gone = (v: SoakAtRate): boolean => v.died === true || v.instantiated === false;
+  const gone = (v: SoakAtRate): boolean => v.timedOut !== true && (v.died === true || v.instantiated === false);
+  const cut = (v: SoakAtRate): boolean => v.timedOut === true;
   const settled = rates.map(([, v]) =>
-    gone(v) || (v.lastRmsDbfs ?? -Infinity) > BLAST_DBFS ? -Infinity : v.lastRmsDbfs ?? -Infinity,
+    gone(v) || cut(v) || (v.lastRmsDbfs ?? -Infinity) > BLAST_DBFS ? -Infinity : v.lastRmsDbfs ?? -Infinity,
   );
   const best = Math.max(...settled);
-  const failures: string[] = [];
-  for (const [rate, v] of rates) {
+  const failed: SoakFailure[] = [];
+  for (const [key, v] of rates) {
+    const rate = Number(key);
+    if (cut(v)) {
+      failed.push({ rate, kind: "timed-out" });
+      continue;
+    }
     if (gone(v)) {
-      failures.push(`died@${rate}`);
+      failed.push({ rate, kind: "died" });
       continue;
     }
     if ((v.nonFiniteWindows ?? 0) > 0) {
-      failures.push(`non-finite@${rate}`);
+      failed.push({ rate, kind: "non-finite" });
       continue;
     }
     if (deadAgainstBest(v.lastRmsDbfs ?? -Infinity, best, policy)) {
-      failures.push(`dead@${rate}`);
+      failed.push({ rate, kind: "dead" });
       continue;
     }
     if ((v.silentWindows ?? 0) > (v.windows ?? 1) * 0.5) {
-      failures.push(`mostly-silent@${rate}`);
+      failed.push({ rate, kind: "mostly-silent" });
       continue;
     }
     const first = v.firstRmsDbfs ?? -99;
-    if (first > BLAST_DBFS) failures.push(`startup-blast@${rate}(${first.toFixed(0)}dBFS)`);
+    if (first > BLAST_DBFS) failed.push({ rate, kind: "startup-blast", detail: `${first.toFixed(0)}dBFS` });
   }
+  const failures = failed.map((f) => `${f.kind}@${f.rate}${f.detail === undefined ? "" : `(${f.detail})`}`);
   return {
     seconds: Math.min(...rates.map(([, v]) => v.seconds ?? 0)),
     failures,
+    failed,
     ratesTested: rates.length,
     rssGrowthKb: Math.max(...rates.map(([, v]) => v.rssGrowthKb ?? 0)),
   };
@@ -480,6 +502,8 @@ export function stabilityReasons(
   /** Whether the plugin shares its process with others (profile isolation, §3a): threads it
    *  spawns and a GUI toolkit it links are cautions only there. */
   sharesProcess = true,
+  /** The console's rate: a soak failure measured at it is the plugin's verdict there. */
+  rate?: number,
 ): readonly HostingReason[] {
   const out: HostingReason[] = [];
   if (m === undefined || m.lifecycle === undefined) {
@@ -519,6 +543,18 @@ export function stabilityReasons(
       }),
     );
   }
+  // A failure MEASURED at the rate being judged is that plugin's verdict at that rate: unsuitable.
+  // At any other rate it only means the soak did not hold everywhere (unsoaked, above). A
+  // supervisor timeout is the harness's fact, never the plugin's.
+  for (const f of soak?.failed ?? []) {
+    if (f.kind === "timed-out" || rate === undefined || f.rate !== rate) continue;
+    out.push(
+      reason("stability", "objective", "unsuitable", HOSTING_CODE.stabilitySoakFailedAtRate, {
+        failure: f.kind,
+        rate: f.rate,
+      }),
+    );
+  }
   const spawned = sharesProcess ? threadsSpawned(m.threads) : 0;
   if (spawned > 0) {
     out.push(
@@ -651,6 +687,16 @@ export function hostingCostReasons(
       }),
     ];
   }
+  // Refuse before comparing: `undefined > ceiling` is false, which is how a gate passes by absence.
+  const missing = costFieldsMissing(perRate);
+  if (missing.length > 0) {
+    return [
+      reason("cost", "objective", "unknown", HOSTING_CODE.costFieldsMissing, {
+        rate: options.rate,
+        missing: missing.join(","),
+      }),
+    ];
+  }
   const out: HostingReason[] = [];
   const p95 = perRate.coreFractionP95;
   // The per-instance ceiling is the HOST's budget (§3a), not the policy's.
@@ -864,7 +910,7 @@ export function classifyPluginHosting(
   // the interposer's counts and the cost are format-blind and read unchanged.
   const reasons: HostingReason[] = descriptor.format === "clap"
     ? [
-        ...stabilityReasons(descriptor.stability, policy, options.pluginBinary, sharesProcess),
+        ...stabilityReasons(descriptor.stability, policy, options.pluginBinary, sharesProcess, options.rate),
         ...rtSafetyReasons(descriptor.rtSafety),
         ...clapRtReasons(descriptor.clap),
         ...clapFeatureReasons(descriptor.clap, profile, descriptor.hasMidiIn),
@@ -873,7 +919,7 @@ export function classifyPluginHosting(
         ...clapTopologyReasons(descriptor.clap, profile.instruments),
       ]
     : [
-        ...stabilityReasons(descriptor.stability, policy, options.pluginBinary, sharesProcess),
+        ...stabilityReasons(descriptor.stability, policy, options.pluginBinary, sharesProcess, options.rate),
         ...rtSafetyReasons(descriptor.rtSafety),
         ...featureReasons(descriptor.lv2Features, descriptor, profile.lv2Features, options.quantum !== undefined, profile.instruments),
         ...hostingCostReasons(descriptor, options, policy),

package/src/index.ts

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

package/src/measure-host.ts

@@ -0,0 +1,112 @@
+// 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.
+ */
+import { isRecord } from "./measurement/guards.js";
+import { SOAK_SWEEP_DB, SOAK_SWEEP_RATIO, SOAK_TIMEOUT_FLOOR_S, SOAK_TIMEOUT_MARGIN } from "./qualify-declarations.js";
+
+/**
+ * Where `text` stops being JSON, scanning ONE value from `i`; returns the index just past the
+ * value, or `-(failing index) - 1` when it is not (negative means failure). A tolerant reader
+ * has to know the exact offset of the first bad character, which `JSON.parse` does not report
+ * portably.
+ */
+function scanValue(t: string, i: number): number {
+  const ws = (k: number): number => {
+    while (k < t.length && (t[k] === " " || t[k] === "\t" || t[k] === "\r" || t[k] === "\n")) k++;
+    return k;
+  };
+  i = ws(i);
+  const c = t[i];
+  if (c === "{" || c === "[") {
+    const close = c === "{" ? "}" : "]";
+    let k = ws(i + 1);
+    if (t[k] === close) return k + 1;
+    for (;;) {
+      if (c === "{") {
+        if (t[k] !== '"') return -k - 1;
+        const key = scanValue(t, k);
+        if (key < 0) return key;
+        k = ws(key);
+        if (t[k] !== ":") return -k - 1;
+        k++;
+      }
+      const v = scanValue(t, k);
+      if (v < 0) return v;
+      k = ws(v);
+      if (t[k] === close) return k + 1;
+      if (t[k] !== ",") return -k - 1;
+      k = ws(k + 1);
+    }
+  }
+  if (c === '"') {
+    let k = i + 1;
+    while (k < t.length) {
+      if (t[k] === "\\") k += 2;
+      else if (t[k] === '"') return k + 1;
+      else if (t[k] === "\n") return -k - 1;
+      else k++;
+    }
+    return -t.length - 1;
+  }
+  const lit = /^(?:-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?|true|false|null)/.exec(t.slice(i, i + 40));
+  return lit === null ? -i - 1 : i + lit[0].length;
+}
+
+/**
+ * The tool's one JSON record out of a stdout a plugin has also printed on (Guitarix:
+ * `using block size: 0`, `convolver disabled`, written by the plugin into the middle of the
+ * tool's own buffered line). The record is the last `{`-leading line that repairs to one valid
+ * object: wherever the text stops being JSON, drop through the end of that line — the
+ * plugin's banner — and join what follows. `undefined` when nothing repairs: the caller
+ * reports a `parse-error`, never a death.
+ */
+export function extractJsonRecord(stdout: string): Record<string, unknown> | undefined {
+  const lines = stdout.split("\n");
+  let offset = 0;
+  const starts: number[] = [];
+  for (const line of lines) {
+    if (line.startsWith("{")) starts.push(offset);
+    offset += line.length + 1;
+  }
+  for (const start of starts.reverse()) {
+    let text = stdout.slice(start);
+    for (let repairs = 0; repairs < 64; repairs++) {
+      const end = scanValue(text, 0);
+      if (end >= 0) {
+        try {
+          const parsed: unknown = JSON.parse(text.slice(0, end));
+          return isRecord(parsed) ? parsed : undefined;
+        } catch {
+          break;
+        }
+      }
+      const bad = -end - 1;
+      const eol = text.indexOf("\n", bad);
+      if (eol < 0) break;
+      text = text.slice(0, bad) + text.slice(eol + 1);
+    }
+  }
+  return undefined;
+}
+
+/**
+ * The wall-clock limit for a soak of `soakAudioS` audio seconds, from the calibration soak's
+ * measured speed: `wallPerAudio * soakAudioS * SOAK_TIMEOUT_MARGIN + SOAK_TIMEOUT_FLOOR_S`,
+ * rounded up. Refuses (throws) on a calibration that measured nothing: a guessed limit is the
+ * fixed 900 s again.
+ */
+export function soakTimeoutSeconds(calibration: { wallSeconds: number; audioSeconds: number }, soakAudioS: number): number {
+  const { wallSeconds, audioSeconds } = calibration;
+  if (!(wallSeconds > 0) || !(audioSeconds > 0) || !(soakAudioS > 0)) {
+    throw new Error("soakTimeoutSeconds: calibration measured no speed");
+  }
+  return Math.ceil((wallSeconds / audioSeconds) * soakAudioS * SOAK_TIMEOUT_MARGIN + SOAK_TIMEOUT_FLOOR_S);
+}
+
+/** The environment that bounds the host's soak sweep to the declared ranges. */
+export function soakSweepEnv(): Record<string, string> {
+  return { OMX_SWEEP_DB: String(SOAK_SWEEP_DB), OMX_SWEEP_RATIO: String(SOAK_SWEEP_RATIO) };
+}

package/src/measurement/cli.ts

@@ -23,6 +23,13 @@
  * mildly hazardous thing to start by accident — a plugin can and does crash its host — so it
  * is gated behind `--run` (or `LV2_MEASURE_RUN=1`), exactly as `benchmark.py` gates itself.
  * `--dry-run` prints the plan and probes nothing.
+ *
+ * ## The hosting pass
+ *
+ * `stability`, `rtSafety` and `features` are measured by the native measurer (`native/lv2-measure.c`,
+ * `lv2_measure`), run once per plugin under the interposer, in its own process so a crash is a
+ * reading and never the run's end. Its lines are the hosting sweep's, read by `sweep-jsonl.ts`.
+ * The plugins are the scan's, or exactly the `--plugins` named, which needs no scan.
  */
 
 import { join } from "node:path";
@@ -32,7 +39,10 @@ import { buildMeasurementDocument } from "./format.js";
 import { measuredPluginsFromProbeOutput } from "./probe-json.js";
 import { buildRun, costMethodFromProbeProvenance, hostFromProbeProvenance } from "./provenance.js";
 import type { MeasurementHost, LatencyMethod } from "./format.js";
-import { type MeasurementDimension, PROBED_DIMENSIONS } from "./vocabulary.js";
+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";
 
 /** Name and version this tool stamps into every document it writes. */
 export const TOOL_NAME = "lv2-measure";
@@ -52,6 +62,8 @@ export interface MeasureOptions {
   readonly dimensions: readonly MeasurementDimension[];
   /** An existing prober scan to reuse instead of scanning. */
   readonly scanPath?: string;
+  /** The plugins the hosting pass measures, instead of every plugin the scan finds. */
+  readonly plugins?: readonly string[];
   /** Where intermediates are written. */
   readonly workDir: string;
   /** Also sweep latency-bearing controls to find parameter-dependent latency. */
@@ -71,11 +83,15 @@ export interface MeasureOptions {
 
 /** One subprocess the pipeline runs, and what it leaves behind. */
 export interface PipelineStep {
-  /** Stable id: `scan` / `latency-declared` / `latency-measured` / `cost`. */
+  /** Stable id: `scan` / `latency-declared` / `latency-measured` / `cost` / `hosting`. */
   readonly id: string;
   readonly command: string;
   readonly args: readonly string[];
-  /** The catalog JSON this step writes — the next step's input. */
+  /** Run once per plugin, the plugin's URI before `args` (the hosting pass). */
+  readonly perPlugin?: boolean;
+  /** Set in the step's environment, over the caller's. */
+  readonly env?: Readonly<Record<string, string>>;
+  /** The catalog JSON this step writes — the next step's input; the hosting pass's JSONL. */
   readonly produces: string;
   /** The dimension this step measures, when it measures one. */
   readonly dimension?: MeasurementDimension;
@@ -84,8 +100,10 @@ export interface PipelineStep {
 /** The full plan: the steps, and where the run's artefacts land. */
 export interface Pipeline {
   readonly steps: readonly PipelineStep[];
-  /** The catalog JSON carrying every annotation once the last step has run. */
-  readonly finalCatalog: string;
+  /** The catalog JSON carrying every annotation once the last step has run; absent when nothing is scanned. */
+  readonly finalCatalog?: string;
+  /** The scan the hosting pass takes its plugins from, when `--plugins` does not name them. */
+  readonly hostingScan?: string;
   /** Where the cost pass writes its machine provenance, when cost is measured. */
   readonly costProvenance?: string;
 }
@@ -98,13 +116,16 @@ export interface Pipeline {
  * ends with one file carrying both — which is also why `finalCatalog` is a property of the
  * pipeline rather than a fixed name.
  */
-export function buildPipeline(options: MeasureOptions): Pipeline {
+export function buildPipeline(options: MeasureOptions, native?: HostingTools): Pipeline {
   const steps: PipelineStep[] = [];
   const benchmark = join(options.toolDir, "benchmark.py");
   const rates = [...options.rates].sort((a, b) => a - b).join(",");
+  const probed = options.dimensions.some((d) => (PROBED_DIMENSIONS as readonly string[]).includes(d));
+  const hosting = options.dimensions.some((d) => (HOSTING_PASS_DIMENSIONS as readonly string[]).includes(d));
+  if (hosting && native === undefined) throw new Error("the hosting pass needs the native measurer and the interposer");
 
   let current = options.scanPath;
-  if (current === undefined) {
+  if (current === undefined && (probed || options.plugins === undefined)) {
     current = join(options.workDir, "scan.json");
     steps.push({
       id: "scan",
@@ -114,7 +135,8 @@ export function buildPipeline(options: MeasureOptions): Pipeline {
     });
   }
 
-  if (options.dimensions.includes("latency")) {
+  // a prober dimension always has a scan: --plugins is refused beside one
+  if (options.dimensions.includes("latency") && current !== undefined) {
     // Declared first: the measured pass sizes its capture window from this figure and
     // computes declaredMismatch against it. Reversing the two silently degrades both.
     const declared = join(options.workDir, "latency-declared.json");
@@ -148,7 +170,7 @@ export function buildPipeline(options: MeasureOptions): Pipeline {
   }
 
   let costProvenance: string | undefined;
-  if (options.dimensions.includes("cost")) {
+  if (options.dimensions.includes("cost") && current !== undefined) {
     costProvenance = join(options.workDir, "cost-provenance.json");
     const cost = join(options.workDir, "cost.json");
     steps.push({
@@ -174,13 +196,77 @@ export function buildPipeline(options: MeasureOptions): Pipeline {
     current = cost;
   }
 
+  if (hosting && native !== undefined) {
+    steps.push({
+      id: "hosting",
+      command: native.tool,
+      args: [
+        String(Math.max(...options.rates)),
+        String(LV2_HOSTING_BLOCK_FRAMES),
+        String(LV2_HOSTING_LIFECYCLES),
+        String(LV2_HOSTING_REPEATS),
+      ],
+      perPlugin: true,
+      env: { LD_PRELOAD: native.interposer, OMX_STIM: "noise" },
+      produces: join(options.workDir, "hosting.jsonl"),
+    });
+  }
+
   return {
     steps,
-    finalCatalog: current,
+    ...(probed && current !== undefined ? { finalCatalog: current } : {}),
+    ...(hosting && options.plugins === undefined && current !== undefined ? { hostingScan: current } : {}),
     ...(costProvenance === undefined ? {} : { costProvenance }),
   };
 }
 
+/** The native measurer and the interposer it runs under, as located for this run. */
+export interface HostingTools {
+  readonly tool: string;
+  readonly interposer: string;
+}
+
+/** The plugin URIs of a scan (a flat array of descriptors), in its order, each once. */
+export function urisFromScan(scan: unknown): string[] {
+  if (!Array.isArray(scan)) return [];
+  const uris = scan.flatMap((entry) => {
+    const uri = isRecord(entry) ? nonEmptyString(entry.uri) : undefined;
+    return uri === undefined ? [] : [uri];
+  });
+  return [...new Set(uris)];
+}
+
+/** How one run of the native measurer ended. `signal` is a death, `timedOut` the run killed for its time. */
+export interface HostingRunResult {
+  readonly status: number | null;
+  readonly signalNumber?: number;
+  readonly timedOut?: boolean;
+  readonly stdout: string;
+}
+
+/**
+ * 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.
+ */
+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 };
+}
+
 // ---------------------------------------------------------------------------
 // Arguments
 // ---------------------------------------------------------------------------
@@ -198,9 +284,12 @@ function parseRates(text: string): number[] | undefined {
   return rates.length > 0 ? [...new Set(rates)].sort((a, b) => a - b) : undefined;
 }
 
+/** What `--dimensions` takes: the prober's, and the hosting pass's. */
+export const MEASURED_DIMENSIONS: readonly MeasurementDimension[] = [...PROBED_DIMENSIONS, ...HOSTING_PASS_DIMENSIONS];
+
 function parseDimensions(text: string): MeasurementDimension[] | undefined {
   const wanted = text.split(",").map((part) => part.trim());
-  const dimensions = PROBED_DIMENSIONS.filter((d) => wanted.includes(d));
+  const dimensions = MEASURED_DIMENSIONS.filter((d) => wanted.includes(d));
   return dimensions.length === wanted.filter((w) => w.length > 0).length && dimensions.length > 0
     ? [...dimensions]
     : undefined;
@@ -222,6 +311,7 @@ export function parseMeasureArgs(
   let rates: readonly number[] | undefined;
   let dimensions: readonly MeasurementDimension[] = PROBED_DIMENSIONS;
   let scanPath: string | undefined;
+  let plugins: readonly string[] | undefined;
   let workDir = defaults.workDir;
   let sweep = false;
   let costCpu: number | undefined;
@@ -255,7 +345,7 @@ export function parseMeasureArgs(
         const value = next();
         const parsed = value === undefined ? undefined : parseDimensions(value);
         if (parsed === undefined) {
-          return { ok: false, error: `--dimensions accepts ${PROBED_DIMENSIONS.join(",")}` };
+          return { ok: false, error: `--dimensions accepts ${MEASURED_DIMENSIONS.join(",")}` };
         }
         dimensions = parsed;
         break;
@@ -266,6 +356,13 @@ export function parseMeasureArgs(
         scanPath = value;
         break;
       }
+      case "--plugins": {
+        const value = next();
+        const uris = value === undefined ? [] : [...new Set(value.split(",").map((u) => u.trim()).filter((u) => u !== ""))];
+        if (uris.length === 0) return { ok: false, error: "--plugins needs a comma-separated list of plugin URIs" };
+        plugins = uris;
+        break;
+      }
       case "--work-dir": {
         const value = next();
         if (value === undefined) return { ok: false, error: "--work-dir needs a path" };
@@ -317,6 +414,12 @@ export function parseMeasureArgs(
       error: "--rates is required: a measurement with no stated rate is not a measurement",
     };
   }
+  if (plugins !== undefined && dimensions.some((d) => (PROBED_DIMENSIONS as readonly string[]).includes(d))) {
+    return {
+      ok: false,
+      error: `--plugins names the hosting pass's plugins; ${PROBED_DIMENSIONS.join(" and ")} measure every plugin the scan finds`,
+    };
+  }
   return {
     ok: true,
     options: {
@@ -330,6 +433,7 @@ export function parseMeasureArgs(
       dryRun,
       ...(outPath === undefined ? {} : { outPath }),
       ...(scanPath === undefined ? {} : { scanPath }),
+      ...(plugins === undefined ? {} : { plugins }),
       ...(costCpu === undefined ? {} : { costCpu }),
       ...(label === undefined ? {} : { label }),
     },
@@ -402,8 +506,10 @@ export function advanceProgress(state: ProgressState, event: ProbeProgress): Pro
 /** Everything {@link assembleDocument} needs beyond the probe output. */
 export interface AssemblyInput {
   readonly options: MeasureOptions;
-  /** The final catalog JSON, already parsed. */
-  readonly catalog: unknown;
+  /** The final catalog JSON, already parsed. Absent when the run measured no prober dimension. */
+  readonly catalog?: unknown;
+  /** The hosting pass's lines ({@link hostingLine}), one per plugin. Absent when it did not run. */
+  readonly hosting?: readonly unknown[];
   /** The cost pass's provenance JSON, already parsed. Absent on a latency-only run. */
   readonly costProvenance?: unknown;
   /** Host facts, for a run whose provenance the cost pass did not write. */
@@ -437,7 +543,10 @@ export const DEFAULT_LATENCY_BLOCK_FRAMES = 512;
  * no cost pass do the caller's collected facts stand in.
  */
 export function assembleDocument(input: AssemblyInput): MeasurementDocument {
-  const plugins: MeasuredPlugin[] = measuredPluginsFromProbeOutput(input.catalog, input.options.dimensions);
+  const probed = input.options.dimensions.filter((d) => (PROBED_DIMENSIONS as readonly string[]).includes(d));
+  const plugins: MeasuredPlugin[] =
+    probed.length > 0 && input.catalog !== undefined ? measuredPluginsFromProbeOutput(input.catalog, probed) : [];
+  if (input.hosting !== undefined) mergeHosting(plugins, measuredPluginsFromSweep({ measurements: input.hosting }), input.options.dimensions);
   const costMethod = costMethodFromProbeProvenance(input.costProvenance);
   const host = hostFromProbeProvenance(input.costProvenance) ?? input.host;
   const run: MeasurementRun = buildRun({
@@ -456,3 +565,25 @@ export function assembleDocument(input: AssemblyInput): MeasurementDocument {
   });
   return buildMeasurementDocument(run, plugins);
 }
+
+/**
+ * The hosting pass's plugins folded into the prober's, by URI: each keeps the hosting dimensions the
+ * run asked for and the pin, and a plugin only the hosting pass measured joins with its own topology.
+ */
+function mergeHosting(plugins: MeasuredPlugin[], hosted: readonly MeasuredPlugin[], dimensions: readonly MeasurementDimension[]): void {
+  for (const h of hosted) {
+    const blocks = {
+      ...(dimensions.includes("stability") && h.stability !== undefined ? { stability: h.stability } : {}),
+      ...(dimensions.includes("rtSafety") && h.rtSafety !== undefined ? { rtSafety: h.rtSafety } : {}),
+      ...(dimensions.includes("features") && h.features !== undefined ? { features: h.features } : {}),
+      ...(h.integrity === undefined ? {} : { integrity: h.integrity }),
+    };
+    const at = plugins.findIndex((p) => p.uri === h.uri);
+    if (at < 0) {
+      plugins.push({ uri: h.uri, ...(h.version === undefined ? {} : { version: h.version }), topology: h.topology, ...blocks });
+    } else {
+      const p = plugins[at]!;
+      plugins[at] = { ...p, ...(p.version === undefined && h.version !== undefined ? { version: h.version } : {}), ...blocks };
+    }
+  }
+}

package/src/measurement/format.ts

@@ -335,6 +335,11 @@ export interface SoakAtRate {
   /** The process died at this rate. Every other field is then absent. */
   readonly died?: boolean;
   readonly instantiated?: boolean;
+  /** The SUPERVISOR stopped the render at its wall-clock limit: a fact about the harness, never a
+   *  failure of the plugin (and never `died`). */
+  readonly timedOut?: boolean;
+  /** The wall-clock limit that cut it, in seconds. */
+  readonly timeoutSeconds?: number;
   readonly seconds?: number;
   readonly blockFrames?: number;
   readonly windows?: number;
@@ -888,6 +893,8 @@ export function readSoakAtRate(value: unknown): SoakAtRate | undefined {
   return {
     ...optional("died", booleanValue(value.died)),
     ...optional("instantiated", booleanValue(value.instantiated)),
+    ...optional("timedOut", booleanValue(value.timedOut)),
+    ...optional("timeoutSeconds", finiteNumber(value.timeoutSeconds)),
     ...optional("seconds", finiteNumber(value.seconds)),
     ...optional("blockFrames", positiveNumber(value.blockFrames)),
     ...optional("windows", finiteNumber(value.windows)),

package/src/measurement/vocabulary.ts

@@ -273,11 +273,17 @@ export const MEASUREMENT_DIMENSIONS = ["latency", "cost", "stability", "rtSafety
 /**
  * The dimensions the standalone prober (`scan.py` + `benchmark.py`, driven by `lv2-measure.mjs`
  * and the console's Setup analysis) can measure. The three hosting dimensions come from a
- * different tool — the `lv2-measure.c` sweep, read by `sweep-jsonl.ts` — so a run asked of the
- * prober for `stability` would be asking it for something it cannot take.
+ * different tool — the native measurer `native/lv2-measure.c`, read by `sweep-jsonl.ts` — so a
+ * run asked of the prober for `stability` would be asking it for something it cannot take.
  */
 export const PROBED_DIMENSIONS = ["latency", "cost"] as const satisfies readonly (typeof MEASUREMENT_DIMENSIONS)[number][];
 
+/**
+ * The dimensions `lv2-measure.mjs`'s hosting pass measures: one run of the native measurer per
+ * plugin, under the interposer, writes all three.
+ */
+export const HOSTING_PASS_DIMENSIONS = ["stability", "rtSafety", "features"] as const satisfies readonly (typeof MEASUREMENT_DIMENSIONS)[number][];
+
 /** One measurable dimension. */
 export type MeasurementDimension = (typeof MEASUREMENT_DIMENSIONS)[number];