@openmixer/plugin-qualify 0.10.1 → 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.10.1",
+  "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__",
@@ -93,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,16 +10,9 @@
  * 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,
@@ -37,7 +30,6 @@ import {
   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";
 import { halfPopulatedRefusal, locateNativeTools } from "./tool-paths.js";
@@ -318,47 +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 host extensions the prober offers beyond the console's, each one of {@link OMX_CLAP_HOST_CONFIGURED_EXTENSIONS}. */
-  readonly offer?: readonly string[];
-}
+// --- 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
@@ -381,44 +333,6 @@ export function clapQualifyTools(
   return { tool: tool!, interposer: interposer! };
 }
 
-/**
- * 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.
- */
-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),
-    ...(options.offer === undefined || options.offer.length === 0 ? [] : ["--offer", options.offer.join(",")]),
-    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 }[];
-}
-
 /**
  * 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`
@@ -432,48 +346,3 @@ export function proberOffer(profile: HostProfile): readonly string[] | undefined
   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[],
-  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;
-    // 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`);
-      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 });
-      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 profile of profiles) {
-      for (const line of runs.get((proberOffer(profile) ?? []).join(","))!) {
-        const doc = rtSafetyDocument(line, profile);
-        documents.push(doc);
-        verdicts.push(rtSafetyVerdict(doc));
-      }
-    }
-  }
-  return { documents, verdicts, failures };
-}

package/src/cost-fields.ts

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

package/src/hosting-codes.ts

@@ -61,6 +61,7 @@ export const HOSTING_CODE = {
   clapFormatNotHosted: 'hosting.clap.format-not-hosted',
   clapExtensionsNotCovered: 'hosting.clap.extensions-not-covered',
   outputNonFinite: 'hosting.output.non-finite',
+  workerNonconforming: 'hosting.worker.nonconforming',
   // The pin (spec §11; one-contract §10.3): a host's refusal at add, by the daemon's code.
   integrityUnpinned: 'hosting.integrity.unpinned',
   integrityBinaryMismatch: 'hosting.integrity.binary-mismatch',

package/src/hosting-suitability.ts

@@ -52,11 +52,19 @@ export interface QualifiedPlugin {
     readonly scalingClass?: string;
     readonly paramSweep?: unknown;
   };
-  /** Measured cost per rate (Hz as a string key). */
+  /** Measured cost: per rate (Hz as a string key), or per rate AND quantum. */
   readonly cpuCost?: {
+    /** One figure per rate, at the block the prober ran: the old format. Read only when `perRateQuantum` is absent. */
     readonly perRate?: Readonly<
       Record<string, { readonly coreFractionP95: number; readonly nsPerSampleMedian: number; readonly nsPerSampleP95: number }>
     >;
+    /**
+     * One figure per rate and quantum, keyed by {@link costPointKey}: a probe output's grid. When this is
+     * present it is the only cost there is, so a pair it lacks is unmeasured, never read from `perRate`.
+     */
+    readonly perRateQuantum?: Readonly<
+      Record<string, { readonly coreFractionP95: number; readonly nsPerSampleMedian: number; readonly nsPerSampleP95: number }>
+    >;
   };
   readonly stability?: PluginStabilityMeasurement;
   readonly rtSafety?: PluginRtSafetyMeasurement;
@@ -306,7 +314,7 @@ export type PluginLv2Features = Omit<FeaturesMeasurement, "unmeasuredReason" | "
 
 export { DEFAULT_HOSTING_POLICY, type HostingPolicy } from "./qualify-declarations.js";
 import { DEFAULT_HOSTING_POLICY, type HostingPolicy } from "./qualify-declarations.js";
-import { costFieldsMissing } from "./cost-fields.js";
+import { costFieldsMissing, costPointKey } from "./cost-fields.js";
 
 /** One declared rate's latency reading from the CLAP qualifier (CLAP spec §3, latency). */
 export interface ClapLatencyAtRate {
@@ -700,7 +708,13 @@ export function hostingCostReasons(
   options: HostingClassifyOptions,
   policy: HostingPolicy,
 ): readonly HostingReason[] {
-  const perRate = descriptor.cpuCost?.perRate?.[String(options.rate)];
+  const grid = descriptor.cpuCost?.perRateQuantum;
+  const perRate =
+    grid === undefined
+      ? descriptor.cpuCost?.perRate?.[String(options.rate)]
+      : options.quantum === undefined
+        ? undefined
+        : grid[costPointKey(options.rate, options.quantum)];
   if (perRate === undefined) {
     return [
       reason("cost", "objective", "unknown", HOSTING_CODE.costUnmeasured, {
@@ -761,6 +775,10 @@ export function hostingLatencyReasons(
   // one the benchmark declared unmeasurable, has not been judged and does not pass by
   // default. The oracle's first fixture omitted latency and still expected `suitable`,
   // which is how this branch was missing — a self-consistent suite proving nothing.
+  // A plugin whose worker interface was refused is not unmeasured by accident: it is not hostable.
+  if (typeof latency?.unmeasurable === "string" && latency.unmeasurable.includes(HOSTING_CODE.workerNonconforming)) {
+    return [reason("latency", "objective", "unsuitable", HOSTING_CODE.workerNonconforming)];
+  }
   if (latency === undefined || latency.unmeasurable !== undefined) {
     return [reason("latency", "objective", "unknown", HOSTING_CODE.latencyUnmeasured)];
   }

package/src/index.ts

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