@openmixer/plugin-qualify 0.9.0 → 0.11.0

package/fixtures/probe-output/success-msi.json

@@ -0,0 +1,363 @@
+{
+  "format": "plugin-hostd.probe-output",
+  "formatVersion": "1.0",
+  "run": {
+    "id": "msi-20261017T221500Z-3569027",
+    "startedAt": "2026-10-17T22:15:00+02:00",
+    "elapsedMs": 184220,
+    "complete": true,
+    "outcome": "probe.ok",
+    "reason": "reference",
+    "protocol": {
+      "name": "plugin-hostd.probe-protocol",
+      "version": 1
+    },
+    "tools": {
+      "runner": "plugin-hostd-probe 0.1.0",
+      "child": "plugin-hostd-probe-clap 0.1.0",
+      "clapCore": "0.9.0",
+      "interposer": "rt-interpose 1"
+    },
+    "via": "runner"
+  },
+  "plugin": {
+    "format": "clap",
+    "id": "org.example.plate",
+    "name": "Plate",
+    "vendor": "Example",
+    "version": "1.4.2",
+    "ownerPackage": "example-plate-1.4.2-1.fc44.x86_64"
+  },
+  "binary": {
+    "path": "/usr/lib64/clap/example-plate.clap",
+    "sha256": "356902794a4eec2122989e072271ef995968131145db918d9a3084ce582f244b",
+    "files": [
+      {
+        "path": "example-plate.clap",
+        "sha256": "356902794a4eec2122989e072271ef995968131145db918d9a3084ce582f244b"
+      }
+    ],
+    "layout": {
+      "scheme": "omx-layout/1",
+      "sha256": "0a3e01399262321514e05af0575ebb0b207a35567ac262a060fde655ee069805"
+    }
+  },
+  "descriptor": {
+    "path": "descriptors/2/clap/org.example.plate@1.4.2-356902794a4e.json",
+    "sha256": "cc312bdd5a9aa62796ebcb5a648c354c5ee45a6a99892425495ccb58a31bc44e",
+    "bytes": 9412
+  },
+  "machine": {
+    "class": {
+      "arch": "x86_64",
+      "family": "intel",
+      "coreBand": "17-32",
+      "clockBand": "4.5GHz+",
+      "preemptRt": false,
+      "cstatesLimited": true
+    },
+    "profile": {
+      "governor": "performance",
+      "turbo": true,
+      "smt": true,
+      "preempt": "PREEMPT_DYNAMIC",
+      "cpuidle": [
+        {
+          "cpu": 22,
+          "state": "POLL",
+          "latencyUs": 0,
+          "disabled": false,
+          "usageDelta": 118
+        },
+        {
+          "cpu": 22,
+          "state": "C1_ACPI",
+          "latencyUs": 1,
+          "disabled": false,
+          "usageDelta": 40210
+        },
+        {
+          "cpu": 22,
+          "state": "C2_ACPI",
+          "latencyUs": 127,
+          "disabled": true,
+          "usageDelta": 0
+        },
+        {
+          "cpu": 22,
+          "state": "C3_ACPI",
+          "latencyUs": 1048,
+          "disabled": true,
+          "usageDelta": 0
+        }
+      ],
+      "meetsProtocol": true,
+      "declaredName": "omx-live-rig"
+    },
+    "pinnedCpus": "22",
+    "reference": {
+      "rig": "msi",
+      "image": "omx-ref-2026-10"
+    }
+  },
+  "offer": {
+    "id": "omx-clap-host",
+    "clapExtensions": [
+      "clap.audio-ports",
+      "clap.latency",
+      "clap.log",
+      "clap.params",
+      "clap.state",
+      "clap.thread-check",
+      "clap.preset-load/2",
+      "clap.track-info/1",
+      "clap.remote-controls/2"
+    ],
+    "realtime": "none"
+  },
+  "limits": {
+    "set": "default",
+    "applied": [
+      {
+        "limit": "wall-clock",
+        "value": 600,
+        "unit": "s",
+        "by": "supervisor"
+      },
+      {
+        "limit": "cpu-time",
+        "value": 540,
+        "unit": "s",
+        "by": "rlimit"
+      },
+      {
+        "limit": "memory",
+        "value": 2147483648,
+        "unit": "bytes",
+        "by": "cgroup"
+      },
+      {
+        "limit": "tasks",
+        "value": 64,
+        "unit": "count",
+        "by": "cgroup"
+      },
+      {
+        "limit": "files",
+        "value": 256,
+        "unit": "count",
+        "by": "rlimit"
+      },
+      {
+        "limit": "file-size",
+        "value": 67108864,
+        "unit": "bytes",
+        "by": "rlimit"
+      },
+      {
+        "limit": "core-dump",
+        "value": 0,
+        "unit": "bytes",
+        "by": "rlimit"
+      },
+      {
+        "limit": "rt-priority",
+        "value": 0,
+        "by": "rlimit"
+      },
+      {
+        "limit": "cpus",
+        "value": "22",
+        "by": "affinity"
+      },
+      {
+        "limit": "no-new-privs",
+        "by": "prctl"
+      },
+      {
+        "limit": "network",
+        "value": "none",
+        "by": "netns"
+      }
+    ],
+    "unavailable": []
+  },
+  "steps": [
+    {
+      "step": "hash",
+      "outcome": "probe.ok",
+      "elapsedMs": 4
+    },
+    {
+      "step": "instantiate",
+      "outcome": "probe.ok",
+      "elapsedMs": 31
+    },
+    {
+      "step": "lifecycle",
+      "outcome": "probe.ok",
+      "elapsedMs": 2210
+    },
+    {
+      "step": "latency",
+      "rate": 48000,
+      "quantum": 128,
+      "outcome": "probe.ok",
+      "elapsedMs": 310
+    },
+    {
+      "step": "cost",
+      "rate": 48000,
+      "quantum": 128,
+      "outcome": "probe.ok",
+      "elapsedMs": 30020
+    },
+    {
+      "step": "rt-safety",
+      "rate": 48000,
+      "quantum": 128,
+      "outcome": "probe.ok",
+      "elapsedMs": 4100
+    },
+    {
+      "step": "latency",
+      "rate": 96000,
+      "quantum": 128,
+      "outcome": "probe.ok",
+      "elapsedMs": 305
+    },
+    {
+      "step": "cost",
+      "rate": 96000,
+      "quantum": 128,
+      "outcome": "probe.ok",
+      "elapsedMs": 30011
+    },
+    {
+      "step": "rt-safety",
+      "rate": 96000,
+      "quantum": 128,
+      "outcome": "probe.ok",
+      "elapsedMs": 4080
+    },
+    {
+      "step": "note-sweep",
+      "outcome": "probe.not-attempted",
+      "elapsedMs": 0,
+      "detail": "no note input"
+    }
+  ],
+  "grid": [
+    {
+      "rate": 48000,
+      "quantum": 128,
+      "outcome": "probe.ok",
+      "latency": {
+        "declaredFrames": 0,
+        "measuredFrames": 0,
+        "method": "impulse-onset"
+      },
+      "cost": {
+        "unit": "ns-per-sample",
+        "median": 41.2,
+        "percentile": {
+          "p": 95,
+          "value": 47.9
+        },
+        "min": 39.8,
+        "max": 112.4,
+        "iqr": 3.1,
+        "blocks": 11250,
+        "warmupBlocks": 64,
+        "warmupMedian": 58.0,
+        "timingFloorNsPerBlock": 180
+      },
+      "rtSafety": {
+        "interposer": true,
+        "swept": true,
+        "sweepApplicable": true,
+        "blocks": 512,
+        "allocations": 0,
+        "locks": 0,
+        "syscalls": 0,
+        "threadViolations": 0,
+        "processErrors": 0,
+        "events": []
+      }
+    },
+    {
+      "rate": 96000,
+      "quantum": 128,
+      "outcome": "probe.ok",
+      "latency": {
+        "declaredFrames": 0,
+        "measuredFrames": 0,
+        "method": "impulse-onset"
+      },
+      "cost": {
+        "unit": "ns-per-sample",
+        "median": 40.7,
+        "percentile": {
+          "p": 95,
+          "value": 46.3
+        },
+        "min": 39.1,
+        "max": 98.0,
+        "iqr": 2.8,
+        "blocks": 22500,
+        "warmupBlocks": 64,
+        "timingFloorNsPerBlock": 180,
+        "samples": {
+          "name": "cost-96000-128",
+          "path": "probes/org.example.plate@1.4.2-356902794a4e.cost-96000-128.bin",
+          "sha256": "5f649130dafd22f1edc70441f9455415d0856f0f7d26cf7274463b82ac2c5813",
+          "bytes": 180000
+        }
+      },
+      "rtSafety": {
+        "interposer": true,
+        "swept": true,
+        "sweepApplicable": true,
+        "blocks": 512,
+        "allocations": 0,
+        "locks": 0,
+        "syscalls": 0,
+        "threadViolations": 0,
+        "processErrors": 0,
+        "events": []
+      }
+    }
+  ],
+  "behaviour": {
+    "lifecycle": {
+      "cycles": 30,
+      "instantiated": 30,
+      "failed": 0
+    },
+    "threads": {
+      "before": 2,
+      "afterFirstInstantiate": 2,
+      "afterAllFreed": 2
+    },
+    "memory": {
+      "rssStartKb": 9120,
+      "rssMaxKb": 14988
+    },
+    "features": {
+      "extensionsAsked": [
+        "clap.audio-ports",
+        "clap.params",
+        "clap.state",
+        "clap.latency"
+      ]
+    }
+  },
+  "logs": [
+    {
+      "name": "stderr",
+      "path": "probes/org.example.plate@1.4.2-356902794a4e.stderr.log",
+      "sha256": "c46928bc87de23b9a8bd235aa1fe67ccb1542c8389ad3f02bf4ab5cff506e98f",
+      "bytes": 212
+    }
+  ]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openmixer/plugin-qualify",
-  "version": "0.9.0",
+  "version": "0.11.0",
   "description": "Qualify audio plugins for real-time hosting: scan, offline latency and cost measurement, a mod-host hosting sweep, and a fail-closed rating.",
   "type": "module",
   "license": "GPL-3.0-or-later",
@@ -67,6 +67,7 @@
     "dist",
     "src",
     "!src/**/*.test.ts",
+    "!src/**/*.support.*",
     "tools",
     "!tools/test_*.py",
     "!**/__pycache__",
@@ -81,7 +82,8 @@
     "test": "vitest run src",
     "lint": "tsc -p tsconfig.lint.json",
     "test:py": "python3 -m pytest tools -q",
-    "check:generated": "node tools/gen-python-declarations.mjs --check"
+    "check:generated": "node tools/gen-python-declarations.mjs --check",
+    "check:private-refs": "tools/private-refs-check.sh && tools/private-refs-check.sh --self-test"
   },
   "devDependencies": {
     "@types/node": "^24.9.0",
@@ -92,5 +94,8 @@
   "publishConfig": {
     "access": "public",
     "provenance": true
+  },
+  "dependencies": {
+    "@openmixer/omx-contract": "^2.16.0"
   }
 }

package/src/clap-loader.ts

@@ -25,6 +25,7 @@ import {
   CLAP_SCAN_TOOL_DEFAULT,
   CLAP_SCAN_TOOL_ENV,
   CLAP_SYSTEM_DIR,
+  CLAP_SYSTEM_DIR_ENV,
   CLAP_USER_DIR,
 } from "./qualify-declarations.js";
 
@@ -428,11 +429,11 @@ export function clapLoader(options: ClapLoaderOptions = {}): PluginLoader {
 
 /**
  * The directories `--all` walks, in order and once each: every non-empty entry of `CLAP_PATH`, then
- * `~/.clap`, then `/usr/lib/clap`.
+ * `~/.clap`, then `/usr/lib/clap` (or the directory `OMX_CLAP_SYSTEM_DIR` names).
  */
 export function clapSearchPath(env: Readonly<Record<string, string | undefined>>, home: string): string[] {
   const named = (env[CLAP_PATH_ENV] ?? "").split(":").filter((d) => d !== "");
-  return [...new Set([...named, join(home, CLAP_USER_DIR), CLAP_SYSTEM_DIR].map((d) => resolve(d)))];
+  return [...new Set([...named, join(home, CLAP_USER_DIR), env[CLAP_SYSTEM_DIR_ENV] || CLAP_SYSTEM_DIR].map((d) => resolve(d)))];
 }
 
 export interface ClapDiscoverOptions extends ClapLoaderOptions {

package/src/clap-qualify.ts

@@ -10,27 +10,26 @@
  * read, a prober that is absent, crashed or timed out, is a {@link ClapQualifyError}: nothing was
  * measured, and nothing is rated.
  */
-import { spawnSync } from "node:child_process";
 import { existsSync } from "node:fs";
 
-import {
-  CLAP_QUALIFY_TIMEOUT_S,
-  CLAP_QUALIFY_TOOL_NAME,
-  CLAP_SWEEP_BLOCKS,
-  CLAP_SWEEP_FRAMES,
-  RT_INTERPOSE_NAME,
-} from "./qualify-declarations.js";
+import { CLAP_QUALIFY_TOOL_NAME, RT_INTERPOSE_NAME } from "./qualify-declarations.js";
 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 type { PluginTarget } from "./loader.js";
+import {
+  OMX_CLAP_HOST_CONFIGURED_EXTENSIONS,
+  OMX_CLAP_HOST_EXTENSIONS,
+  OPENMIXER_CONSOLE_PROFILE,
+  type HostProfile,
+} from "./host-profiles.js";
 import type { QualifyVerdict } from "./qualify-cli.js";
 import { RATING_SEVERITY, worstRating, type SuitabilityRating } from "./rating.js";
 import { halfPopulatedRefusal, locateNativeTools } from "./tool-paths.js";
@@ -51,6 +50,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 +70,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 +150,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 +199,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 +211,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 +245,7 @@ export interface RtSafetyDocument {
     readonly hostExtensions: readonly string[];
     readonly clap: ClapProbedFacts;
     readonly rtSafety: ClapRtSafetyReading;
+    readonly noteSweep: ClapNoteSweepReading;
     readonly integrity: IntegrityMeasurement;
   };
 }
@@ -225,7 +264,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 +283,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,
+    },
   };
 }
 
@@ -265,45 +310,7 @@ export function rtSafetyDocumentName(doc: RtSafetyDocument): string {
   return `${doc.plugin.binary.sha256}.${doc.console}.rt-safety.json`;
 }
 
-// --- running the prober --------------------------------------------------------------------------
-
-/** What a run of the prober gave back; `error` is a spawn failure, `signal` a death. */
-export interface ClapQualifyRunResult {
-  readonly status: number | null;
-  readonly signal?: string | null;
-  readonly stdout: string;
-  readonly stderr?: string;
-  readonly error?: Error;
-}
-
-export type ClapQualifyRun = (
-  tool: string,
-  args: readonly string[],
-  env: Readonly<Record<string, string | undefined>>,
-  timeoutMs: number,
-) => ClapQualifyRunResult;
-
-const spawnQualify: ClapQualifyRun = (tool, args, env, timeoutMs) => {
-  const r = spawnSync(tool, [...args], { encoding: "utf8", env: { ...env }, timeout: timeoutMs, maxBuffer: 64 << 20 });
-  return {
-    status: r.status,
-    signal: r.signal,
-    stdout: r.stdout ?? "",
-    stderr: r.stderr ?? "",
-    ...(r.error === undefined ? {} : { error: r.error }),
-  };
-};
-
-export interface ClapQualifyOptions {
-  /** The rates the plugin is activated and swept at. */
-  readonly rates: readonly number[];
-  /** Runs the prober; the default spawns it. */
-  readonly run?: ClapQualifyRun;
-  /** Where the two settings are read from; the default is `process.env`. */
-  readonly env?: Readonly<Record<string, string | undefined>>;
-  /** Whether a file exists; the default asks the filesystem. */
-  readonly exists?: (path: string) => boolean;
-}
+// --- the prober and the interposer a run uses ---------------------------------------------------
 
 /**
  * The prober and the interposer this run uses: each its setting, else both from one place, the
@@ -327,76 +334,15 @@ export function clapQualifyTools(
 }
 
 /**
- * Qualify the plugins of one `.clap` (all of them, or the one `id` names) under the interposer.
- * Absent tools, a crash, a timeout, a load failure or an unreadable line throw: none of them is a
- * measurement.
+ * 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 qualifyClap(binaryPath: string, id: string | undefined, options: ClapQualifyOptions): ClapQualifyLine[] {
-  const env = options.env ?? process.env;
-  const { tool, interposer } = clapQualifyTools(env, options.exists ?? existsSync);
-  const args = [
-    "--rates",
-    options.rates.join(","),
-    "--block",
-    String(CLAP_SWEEP_FRAMES),
-    "--blocks",
-    String(CLAP_SWEEP_BLOCKS),
-    binaryPath,
-    ...(id === undefined ? [] : [id]),
-  ];
-  const r = (options.run ?? spawnQualify)(tool, args, { ...env, LD_PRELOAD: interposer }, CLAP_QUALIFY_TIMEOUT_S * 1000);
-  if (r.error !== undefined) throw new ClapQualifyError(`cannot run ${tool}: ${r.error.message}`);
-  if (r.signal) throw new ClapQualifyError(`${binaryPath} killed the prober (${r.signal})`);
-  if (r.status !== 0) throw new ClapQualifyError(`${tool} exited ${String(r.status)} on ${binaryPath}: ${(r.stderr ?? "").trim()}`);
-  const lines = parseClapQualifyOutput(r.stdout);
-  if (lines.length === 0) throw new ClapQualifyError(`${tool} printed nothing for ${binaryPath}`);
-  return lines;
-}
-
-// --- the CLI's CLAP pass -------------------------------------------------------------------------
-
-/** What the CLAP pass of one run produced: a document per plugin and console, and a row per verdict. */
-export interface ClapQualifyPass {
-  readonly documents: readonly RtSafetyDocument[];
-  readonly verdicts: readonly QualifyVerdict[];
-  /** Each target that could not be measured, with why; its verdict rows read `unknown`, unmeasured. */
-  readonly failures: readonly { readonly uri: string; readonly problem: string }[];
-}
-
-/**
- * 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.
- */
-export function qualifyClapTargets(
-  targets: readonly PluginTarget[],
-  options: ClapQualifyOptions & { readonly profiles?: readonly HostProfile[] },
-): ClapQualifyPass {
-  const profiles = options.profiles ?? [OPENMIXER_CONSOLE_PROFILE];
-  const documents: RtSafetyDocument[] = [];
-  const verdicts: QualifyVerdict[] = [];
-  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[];
-    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);
-    } catch (e) {
-      if (!(e instanceof ClapQualifyError)) throw e;
-      failures.push({ uri: target.uri, problem: e.message });
-      for (const profile of profiles) {
-        verdicts.push({ uri: target.uri, host: profile.id, measured: false, rating: "unknown", qualified: false, deciding: "not-measured" });
-      }
-      continue;
-    }
-    for (const line of lines) {
-      for (const profile of profiles) {
-        const doc = rtSafetyDocument(line, profile);
-        documents.push(doc);
-        verdicts.push(rtSafetyVerdict(doc));
-      }
-    }
-  }
-  return { documents, verdicts, failures };
+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));
 }