@openmixer/plugin-qualify 0.17.1 → 0.17.3

package/src/host-admission.ts

@@ -22,9 +22,16 @@ export function admittedHostOf(profile: HostProfile): AdmittedHost | undefined {
   return ADMITTED_HOSTS.find((h) => h === profile.id);
 }
 
+/**
+ * plugin-hostd's LV2 adapter, omx-clap-host: an LV2 plugin is run under it once, as under mod-host, and the record
+ * carries the outcome as its own step beside the verdicts (plugin-qualify#223), which it does not change: the
+ * omx-clap-host verdict of an LV2 plugin stays the in-process measurement. It is what the removal of mod-host counts.
+ */
+export const ADAPTER_HOST = "omx-clap-host";
+
 /** What running the plugin under one host came to. */
 export interface HostAdmission {
-  readonly host: AdmittedHost;
+  readonly host: AdmittedHost | typeof ADAPTER_HOST;
   /** False when the host could not be run (not installed): there is no evidence either way. */
   readonly measured: boolean;
   readonly admitted: boolean;
@@ -33,15 +40,16 @@ export interface HostAdmission {
   readonly params: Readonly<Record<string, string | number>>;
 }
 
-const admitted = (host: AdmittedHost): HostAdmission => ({ host, measured: true, admitted: true, params: {} });
-const refused = (host: AdmittedHost, code: string, params: HostAdmission["params"] = {}): HostAdmission => ({
+type ProtocolHost = "mod-host" | typeof ADAPTER_HOST;
+const admitted = (host: HostAdmission["host"]): HostAdmission => ({ host, measured: true, admitted: true, params: {} });
+const refused = (host: HostAdmission["host"], code: string, params: HostAdmission["params"] = {}): HostAdmission => ({
   host,
   measured: true,
   admitted: false,
   code: `${host}.${code}`,
   params,
 });
-const notInstalled = (host: AdmittedHost): HostAdmission => ({ host, measured: false, admitted: false, code: `${host}.not-installed`, params: {} });
+const notInstalled = (host: HostAdmission["host"]): HostAdmission => ({ host, measured: false, admitted: false, code: `${host}.not-installed`, params: {} });
 
 /** One command mod-host was sent and what came of it: its `resp` number, or how the host died. */
 export interface ModHostStep {
@@ -57,20 +65,25 @@ export interface ModHostRun {
   readonly steps: readonly ModHostStep[];
 }
 
-/** The verdict of a mod-host run: the first step that did not answer `resp 0` decides. */
-export function classifyModHostRun(run: ModHostRun): HostAdmission {
-  if (!run.installed) return notInstalled("mod-host");
+/** The verdict of a run of a host that speaks mod-host's protocol: the first step that did not answer `resp 0` decides. */
+export function classifyProtocolRun(host: ProtocolHost, run: ModHostRun): HostAdmission {
+  if (!run.installed) return notInstalled(host);
   for (const s of run.steps) {
     if (s.died !== undefined) {
-      if (s.died.startsWith("SIG")) return refused("mod-host", `signal-${s.died}`, { step: s.cmd });
-      return s.cmd === "add" ? refused("mod-host", "died-on-add", { how: s.died }) : refused("mod-host", "died", { step: s.cmd, how: s.died });
+      if (s.died.startsWith("SIG")) return refused(host, `signal-${s.died}`, { step: s.cmd });
+      return s.cmd === "add" ? refused(host, "died-on-add", { how: s.died }) : refused(host, "died", { step: s.cmd, how: s.died });
     }
-    if (s.resp === undefined) return refused("mod-host", "no-answer", { step: s.cmd });
-    // mod-host answers an error as a negative number (`resp -102`); the code carries its magnitude
-    if (s.resp < 0) return refused("mod-host", `resp-${-s.resp}`, { step: s.cmd, resp: s.resp });
+    if (s.resp === undefined) return refused(host, "no-answer", { step: s.cmd });
+    // the host answers an error as a negative number (`resp -102`); the code carries its magnitude
+    if (s.resp < 0) return refused(host, `resp-${-s.resp}`, { step: s.cmd, resp: s.resp });
   }
-  if (run.steps.length === 0) return refused("mod-host", "no-answer");
-  return admitted("mod-host");
+  if (run.steps.length === 0) return refused(host, "no-answer");
+  return admitted(host);
+}
+
+/** The verdict of a mod-host run. */
+export function classifyModHostRun(run: ModHostRun): HostAdmission {
+  return classifyProtocolRun("mod-host", run);
 }
 
 /** What `jalv -n <name> <uri>` did in its window. */
@@ -101,36 +114,69 @@ export const JALV_HOSTED_MS = 3000;
 /** The wall clock of one whole mod-host admission, in milliseconds. */
 export const MOD_HOST_ADMISSION_MS = 30000;
 
+/**
+ * The runs of one plugin under the installed hosts. `env` is the environment each host starts with: its `LV2_PATH`
+ * must be the device's LV2 directories, the ones the host sees in use (plugin-qualify#224: a mod-host started with no
+ * `LV2_PATH` sees only lilv's defaults and answers -101 for a plugin it runs every day).
+ */
 export interface AdmissionRuns {
-  readonly modHost: (uri: string) => ModHostRun;
-  readonly jalv: (uri: string) => JalvRun;
+  readonly modHost: (uri: string, env?: Readonly<Record<string, string | undefined>>) => ModHostRun;
+  readonly jalv: (uri: string, env?: Readonly<Record<string, string | undefined>>) => JalvRun;
+  /** The run under plugin-hostd's LV2 adapter; a set without it records no adapter step. */
+  readonly adapter?: (uri: string, env?: Readonly<Record<string, string | undefined>>) => ModHostRun;
 }
 
 const MOD_HOST_ADMIT = fileURLToPath(new URL("../tools/mod-host-admit.mjs", import.meta.url));
 
 /** The runs against the installed hosts. */
 export const SPAWNED_ADMISSIONS: AdmissionRuns = {
-  modHost(uri) {
-    const r = spawnSync(process.execPath, [MOD_HOST_ADMIT, uri], { encoding: "utf8", timeout: MOD_HOST_ADMISSION_MS });
+  adapter(uri, env) {
+    const r = spawnSync(process.execPath, [MOD_HOST_ADMIT, uri, ADAPTER_HOST], { encoding: "utf8", timeout: MOD_HOST_ADMISSION_MS, ...(env === undefined ? {} : { env: { ...env } }) });
+    if (r.error !== undefined || r.status !== 0) {
+      throw new Error(`${ADAPTER_HOST} admission of ${uri} gave no answer (${r.error?.message ?? `exit ${String(r.status)}`}): ${(r.stderr ?? "").trim()}`);
+    }
+    return JSON.parse(r.stdout) as ModHostRun;
+  },
+  modHost(uri, env) {
+    const r = spawnSync(process.execPath, [MOD_HOST_ADMIT, uri], { encoding: "utf8", timeout: MOD_HOST_ADMISSION_MS, ...(env === undefined ? {} : { env: { ...env } }) });
     if (r.error !== undefined || r.status !== 0) {
       throw new Error(`mod-host admission of ${uri} gave no answer (${r.error?.message ?? `exit ${String(r.status)}`}): ${(r.stderr ?? "").trim()}`);
     }
     return JSON.parse(r.stdout) as ModHostRun;
   },
-  jalv(uri) {
-    const r = spawnSync("jalv", ["-n", "plugin-qualify", uri], { encoding: "utf8", timeout: JALV_HOSTED_MS, input: "" });
+  jalv(uri, env) {
+    const r = spawnSync("jalv", ["-n", "plugin-qualify", uri], { encoding: "utf8", timeout: JALV_HOSTED_MS, input: "", ...(env === undefined ? {} : { env: { ...env } }) });
     const code = (r.error as NodeJS.ErrnoException | undefined)?.code;
     if (code === "ENOENT") return { installed: false, stillRunning: false, status: null, signal: null, stderr: "" };
     return { installed: true, stillRunning: code === "ETIMEDOUT", status: r.status, signal: code === "ETIMEDOUT" ? null : r.signal, stderr: r.stderr ?? "" };
   },
 };
 
-/** One admission of `uri` under `host`. */
-export function admitPlugin(host: AdmittedHost, uri: string, runs: AdmissionRuns = SPAWNED_ADMISSIONS): HostAdmission {
+/** One admission of `uri` under `host`, the host started with `env` (its `LV2_PATH` the device's LV2 directories). */
+export function admitPlugin(
+  host: AdmittedHost,
+  uri: string,
+  runs: AdmissionRuns = SPAWNED_ADMISSIONS,
+  env?: Readonly<Record<string, string | undefined>>,
+): HostAdmission {
   try {
-    return host === "mod-host" ? classifyModHostRun(runs.modHost(uri)) : classifyJalvRun(runs.jalv(uri));
+    return host === "mod-host" ? classifyModHostRun(runs.modHost(uri, env)) : classifyJalvRun(runs.jalv(uri, env));
   } catch (e) {
     // the run itself broke: nothing was learned about the plugin, so nothing is rated
     return { host, measured: false, admitted: false, code: `${host}.admission-failed`, params: { problem: e instanceof Error ? e.message : String(e) } };
   }
 }
+
+/** The run of an LV2 plugin under plugin-hostd's LV2 adapter, `undefined` when the runs have none (plugin-qualify#223). */
+export function admitUnderAdapter(
+  uri: string,
+  runs: AdmissionRuns = SPAWNED_ADMISSIONS,
+  env?: Readonly<Record<string, string | undefined>>,
+): HostAdmission | undefined {
+  if (runs.adapter === undefined) return undefined;
+  try {
+    return classifyProtocolRun(ADAPTER_HOST, runs.adapter(uri, env));
+  } catch (e) {
+    return { host: ADAPTER_HOST, measured: false, admitted: false, code: `${ADAPTER_HOST}.admission-failed`, params: { problem: e instanceof Error ? e.message : String(e) } };
+  }
+}

package/src/hostd-pin-files.ts

@@ -0,0 +1,75 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Copyright (C) 2026 Pau Aliagas <linuxnow@gmail.com>
+/**
+ * The files a pin holds, as plugin-hostd collects them (plugin-qualify#228). One definition of a plugin's files: the
+ * daemon's, the list an add checks before it hashes them (`pins_check`), which `plugin-hostd --pin-files <uri>` prints
+ * (plugin-hostd 0.15.0 and later). This module never works the list out itself: it runs the daemon on the device's LV2
+ * directories, reads `root <dir>` and the `file <name>` lines, and hashes exactly those files.
+ */
+import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+/** The daemon binary, else `plugin-hostd` on the PATH. */
+export const HOSTD_ENV = "PLUGIN_HOSTD";
+
+export interface PinFilesRunResult {
+  readonly status: number | null;
+  readonly stdout: string;
+  readonly stderr: string;
+  /** The daemon is not installed. */
+  readonly missing?: boolean;
+}
+
+/** One run of `plugin-hostd --pin-files <uri>` with `lv2_path` set to `lv2Dirs`. */
+export type PinFilesRun = (uri: string, lv2Dirs: readonly string[], env: Readonly<Record<string, string | undefined>>) => PinFilesRunResult;
+
+export const SPAWNED_PIN_FILES: PinFilesRun = (uri, lv2Dirs, env) => {
+  const dir = mkdtempSync(join(tmpdir(), "plugin-qualify-pin-files-"));
+  try {
+    const conf = join(dir, "plugin-hostd.conf");
+    writeFileSync(conf, `lv2_path ${lv2Dirs.join(":")}\n`);
+    const r = spawnSync(env[HOSTD_ENV] ?? "plugin-hostd", ["-c", conf, "--pin-files", uri], { encoding: "utf8", timeout: 30000, env: { ...env } });
+    const missing = (r.error as NodeJS.ErrnoException | undefined)?.code === "ENOENT";
+    return { status: r.status, stdout: r.stdout ?? "", stderr: r.stderr ?? "", ...(missing ? { missing } : {}) };
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+};
+
+export type PinFiles =
+  | { readonly ok: true; readonly root: string; readonly files: readonly { readonly path: string; readonly sha256: string }[] }
+  | { readonly ok: false; readonly detail: string };
+
+/** The files plugin-hostd collects for `uri`, each hashed; why not, when it cannot say. */
+export function hostdPinFiles(
+  uri: string,
+  lv2Dirs: readonly string[],
+  env: Readonly<Record<string, string | undefined>> = process.env,
+  run: PinFilesRun = SPAWNED_PIN_FILES,
+  read: (path: string) => Buffer = (p) => readFileSync(p),
+): PinFiles {
+  const r = run(uri, lv2Dirs, env);
+  if (r.missing) return { ok: false, detail: "plugin-hostd is not installed: the files of a pin are plugin-hostd's to name" };
+  if (r.status !== 0) {
+    const why = r.stdout.startsWith("Usage:")
+      ? "this plugin-hostd has no --pin-files (plugin-hostd 0.15.0 or later names the files of a pin)"
+      : r.stderr.trim().split("\n").pop() || `plugin-hostd --pin-files exited ${String(r.status)}`;
+    return { ok: false, detail: why };
+  }
+  let root: string | undefined;
+  const names: string[] = [];
+  for (const line of r.stdout.split("\n")) {
+    if (line.startsWith("root ")) root = line.slice(5);
+    else if (line.startsWith("file ")) names.push(line.slice(5));
+  }
+  if (root === undefined || names.length === 0) return { ok: false, detail: "plugin-hostd --pin-files printed no root or no file" };
+  try {
+    const files = names.map((path) => ({ path, sha256: createHash("sha256").update(read(join(root!, path))).digest("hex") }));
+    return { ok: true, root, files: files.sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0)) };
+  } catch (e) {
+    return { ok: false, detail: `a file plugin-hostd names cannot be read: ${e instanceof Error ? e.message : String(e)}` };
+  }
+}

package/src/probe-judge.ts

@@ -133,7 +133,9 @@ export function clapLineFromProbeOutput(output: ProbeOutput, facts: JudgeFacts =
   const points = okPoints(output);
   const latency: Record<string, { declaredFrames: number; measuredFrames: number }> = {};
   for (const p of points) {
-    if (p.latency !== undefined && latency[String(p.rate)] === undefined) latency[String(p.rate)] = p.latency;
+    if (p.latency?.measuredFrames !== undefined && latency[String(p.rate)] === undefined) {
+      latency[String(p.rate)] = { declaredFrames: p.latency.declaredFrames, measuredFrames: p.latency.measuredFrames };
+    }
   }
   const withRt = points.filter((p) => p.rtSafety !== undefined);
   return {
@@ -188,6 +190,8 @@ export interface HostJudgment {
 
 export interface Judgment {
   readonly output: ProbeOutput;
+  /** An LV2 plugin's run under plugin-hostd's LV2 adapter, beside the verdicts (plugin-qualify#223). */
+  readonly adapter?: HostAdmission;
   readonly hosts: readonly HostJudgment[];
   /** For a CLAP plugin, the document of each host that today's judge writes; the pins are taken from these. */
   readonly documents: readonly RtSafetyDocument[];

package/src/probe-output-fixtures.ts

@@ -198,7 +198,10 @@ export function probeOutputOfLv2Line(line: Lv2MeasureLine): Record<string, any>
       method: latency.from === "note" ? "note-onset" : "impulse-onset",
       ...(latency.from === "note" ? { heard: true } : {}),
     };
-  } else absent("latency", latency);
+  } else {
+    absent("latency", latency);
+    if (latency?.declaredFrames !== undefined) point["latency"] = { declaredFrames: latency.declaredFrames };
+  }
   if (cost?.nsPerSampleMedian !== undefined) {
     steps.push({ step: "cost", rate, quantum, outcome: "probe.ok", elapsedMs: 1 });
     point["cost"] = {

package/src/probe-output.ts

@@ -91,7 +91,8 @@ export interface ProbeGridPoint {
   readonly rate: number;
   readonly quantum: number;
   readonly outcome: string;
-  readonly latency?: { readonly declaredFrames: number; readonly measuredFrames: number };
+  /** `measuredFrames` is absent where the probe did not measure; the declared figure is kept whenever the plugin loaded (#201). */
+  readonly latency?: { readonly declaredFrames: number; readonly measuredFrames?: number };
   readonly cost?: ProbeCost;
   readonly rtSafety?: ProbeRtSafety;
   readonly noteSweep?: ProbeNoteSweep;
@@ -296,7 +297,10 @@ function readPoint(v: unknown, i: number): ProbeGridPoint {
   let latency: ProbeGridPoint["latency"];
   if (latencyIn !== undefined) {
     const l = record(latencyIn, `${where} latency`);
-    latency = { declaredFrames: count(l, "declaredFrames", `${where} latency`), measuredFrames: count(l, "measuredFrames", `${where} latency`) };
+    latency = {
+      declaredFrames: count(l, "declaredFrames", `${where} latency`),
+      ...(l["measuredFrames"] === undefined ? {} : { measuredFrames: count(l, "measuredFrames", `${where} latency`) }),
+    };
   }
   return {
     rate: posInt(o, "rate", where),

package/src/probe-runner.ts

@@ -22,7 +22,7 @@ import type { HostProfile } from "./host-profiles.js";
 import { OPENMIXER_CONSOLE_PROFILE, shippedHostProfile } from "./host-profiles.js";
 import { IN_PROCESS_TIER_HOST, ISOLATED_TIER_HOST } from "./qualification-record.js";
 import type { PluginTarget } from "./loader.js";
-import { SPAWNED_ADMISSIONS, admitPlugin, admittedHostOf, type AdmissionRuns, type HostAdmission } from "./host-admission.js";
+import { SPAWNED_ADMISSIONS, admitPlugin, admitUnderAdapter, admittedHostOf, type AdmissionRuns, type HostAdmission } from "./host-admission.js";
 import { judgeProbeOutput, judgmentVerdicts, type Judgment } from "./probe-judge.js";
 import { readProbeOutput, type ProbeOutput } from "./probe-output.js";
 import { budgetCells, gridCells, runnerInvocations, type GridCell, type GridSpec, type RunnerInvocation } from "./measurement-grid.js";
@@ -261,6 +261,11 @@ export function qualifyTargets(
   options: ProbeTargetOptions & {
     readonly profiles?: readonly HostProfile[];
     readonly admissions?: AdmissionRuns;
+    /**
+     * The LV2 directories the hosts of an admission see (`LV2_PATH`), the device's as the sync's settings name them;
+     * absent, they get the run's environment as it is.
+     */
+    readonly admissionLv2Path?: readonly string[];
     /** How the grid is chosen; with it, each target's cells come from the hosts it is judged under. */
     readonly grid?: GridSpec;
     /** The quanta of a `full` grid; else `QUALIFY_QUANTA`. */
@@ -271,6 +276,8 @@ export function qualifyTargets(
 ): ProbePass {
   const profiles = options.profiles ?? [OPENMIXER_CONSOLE_PROFILE];
   const admissionRuns = options.admissions ?? SPAWNED_ADMISSIONS;
+  const runEnvironment = options.env ?? process.env;
+  const admissionEnv = options.admissionLv2Path === undefined ? runEnvironment : { ...runEnvironment, LV2_PATH: options.admissionLv2Path.join(":") };
   const runs: { bytes: Buffer; judgment: Judgment }[] = [];
   const verdicts: QualifyVerdict[] = [];
   const documents: RtSafetyDocument[] = [];
@@ -289,10 +296,12 @@ export function qualifyTargets(
     const measured = cells === undefined ? {} : { cells: budgetCells(cells, options.cellsPerPluginBudget) };
     // an LV2 plugin is run under each measured host once, whichever probe output it is judged with
     const admissions: Record<string, HostAdmission> = {};
+    // an LV2 plugin is also run once under plugin-hostd's LV2 adapter, recorded beside the verdicts (#223)
+    const adapter = target.format === "lv2" ? admitUnderAdapter(target.uri, admissionRuns, admissionEnv) : undefined;
     if (target.format === "lv2") {
       for (const profile of judgedProfiles) {
         const host = admittedHostOf(profile);
-        if (host !== undefined) admissions[profile.id] = admitPlugin(host, target.uri, admissionRuns);
+        if (host !== undefined) admissions[profile.id] = admitPlugin(host, target.uri, admissionRuns, admissionEnv);
       }
     }
     for (const profile of judgedProfiles) {
@@ -309,7 +318,8 @@ export function qualifyTargets(
     try {
       for (const { offer, profiles: forOffer } of byOffer.values()) {
         const probed = probeTarget(target, { ...options, ...measured, offer });
-        const judgment = judgeProbeOutput(probed.output, forOffer, { admissions });
+        const plain = judgeProbeOutput(probed.output, forOffer, { admissions });
+        const judgment = adapter === undefined ? plain : { ...plain, adapter };
         targetRuns.push({ bytes: probed.bytes, judgment });
         for (const v of judgmentVerdicts(judgment)) judged.set(v.host, v);
       }

package/src/qualification-record.ts

@@ -93,13 +93,15 @@ export function unmeasuredFigures(output: ProbeOutput): readonly UnmeasuredFigur
 
 /** A cell's latency when the run took no figure: the contract's unmeasured word and the hosting code a reader classifies by. */
 export interface UnmeasuredLatency {
+  /** The figure the plugin declared (LV2 latency port, CLAP latency extension) when it loaded but the probe did not measure. */
+  readonly declaredFrames?: number;
   readonly unmeasuredReason: string;
   readonly code: string;
 }
 
 /** A grid point as the record writes it: every cell carries `latency`, the figures or why there are none (#201). */
 export type RecordGridPoint = Omit<ProbeGridPoint, "latency"> & {
-  readonly latency: NonNullable<ProbeGridPoint["latency"]> | UnmeasuredLatency;
+  readonly latency: (Omit<NonNullable<ProbeGridPoint["latency"]>, "measuredFrames"> & { readonly measuredFrames: number }) | UnmeasuredLatency;
 };
 
 const UNMEASURED_WORDS: ReadonlySet<string> = new Set(Object.values(MEASUREMENT_UNMEASURED_REASONS).map((r) => r.word));
@@ -120,7 +122,13 @@ const OUTCOME_WORD: Readonly<Record<string, string>> = {
  * older than the latency arm writes it.
  */
 export function latencyOfCell(output: ProbeOutput, point: ProbeGridPoint): RecordGridPoint["latency"] {
-  if (point.latency !== undefined) return point.latency;
+  const had = point.latency;
+  if (had?.measuredFrames !== undefined) return { ...had, measuredFrames: had.measuredFrames };
+  const why = unmeasuredOfCell(output, point);
+  return had === undefined ? why : { declaredFrames: had.declaredFrames, ...why };
+}
+
+function unmeasuredOfCell(output: ProbeOutput, point: ProbeGridPoint): UnmeasuredLatency {
   const code = HOSTING_CODE.latencyUnmeasured;
   if (point.outcome !== PROBE_OK) return { unmeasuredReason: OUTCOME_WORD[point.outcome] ?? word("probeError"), code };
   const step = output.steps.find((st) => st.step === "latency" && st.rate === point.rate && (st.quantum === undefined || st.quantum === point.quantum));
@@ -162,6 +170,11 @@ export interface QualificationRecord {
   readonly testedVersion?: string;
   readonly binary: ProbeOutput["binary"];
   readonly verdicts: readonly RecordVerdict[];
+  /**
+   * An LV2 plugin run under plugin-hostd's LV2 adapter (omx-clap-host), as under mod-host: admitted, or refused with
+   * its code, or `measured: false` when it was not tried. Beside the verdicts, which it does not change (#223).
+   */
+  readonly adapter?: { readonly host: string; readonly measured: boolean; readonly admitted: boolean; readonly code?: string; readonly params: Readonly<Record<string, string | number>> };
   readonly tiers: RecordTiers;
   /** The cost reasons at each host's rate and quantum, beside the verdicts; an instrument's with the notes it held. */
   readonly cost: readonly {
@@ -266,6 +279,7 @@ export function buildQualificationRecord(
       ...(h.verdict.deciding === undefined ? {} : { deciding: h.verdict.deciding }),
       reasons: h.reasons,
     })),
+    ...(judgment.adapter === undefined ? {} : { adapter: judgment.adapter }),
     tiers: tiersOf(judgment),
     cost: judgment.hosts.map((h) => ({ host: h.verdict.host, ...h.cost })),
     measurements: {

package/src/qualify-cli.ts

@@ -20,7 +20,7 @@ import { classifyPluginHosting, type QualifiedPlugin } from "./hosting-suitabili
 import type { SuitabilityRating } from "./rating.js";
 import type { PluginLoader, PluginTarget } from "./loader.js";
 import { EXIT_CODE, OUTPUT_FORMATS, QUALIFY_OPTIONS, type OutputFormat } from "./qualify-options.js";
-import { GRID_HOSTS, parseGridSpec, type GridSpec } from "./measurement-grid.js";
+import { GRID_FULL, parseGridSpec, type GridSpec } from "./measurement-grid.js";
 import { parseMemoryLimit } from "./memory-bound.js";
 
 export interface QualifyArgs {
@@ -91,7 +91,7 @@ export function parseQualifyArgs(argv: readonly string[]): ParseResult {
   if (quanta === undefined) return { ok: false, error: "--quanta must be positive integers, comma-separated" };
   const gridText = seen.get("--grid") as string | undefined;
   if (gridText !== undefined && seen.has("--grid-hosts") && gridText.trim() !== "hosts") return { ok: false, error: "--grid-hosts and --grid name two grids; give one" };
-  const grid = gridText === undefined ? { ok: true as const, spec: GRID_HOSTS } : parseGridSpec(gridText);
+  const grid = gridText === undefined && seen.has("--grid-hosts") ? parseGridSpec("hosts") : gridText === undefined ? { ok: true as const, spec: GRID_FULL } : parseGridSpec(gridText);
   if (!grid.ok) return { ok: false, error: `--grid: ${grid.error}` };
   const count = (flag: string, min: number): number | undefined => {
     const v = seen.get(flag) as string | undefined;
@@ -175,11 +175,15 @@ export function resolveTargets(targets: readonly string[], loaders: readonly Plu
       continue;
     }
     for (const p of found) {
-      const prior = plugins.get(p.uri);
+      // Two files can hold a plugin of the same id (a bundle's formats, or copies of it): the file is part of the key.
+      const key = `${p.uri}\0${p.binaryPath ?? ""}`;
+      const prior = plugins.get(key);
       // A URI and its bundle name the same plugin: keep the richer record (bundle, binary).
-      if (prior === undefined || (prior.binary === undefined && p.binary !== undefined)) plugins.set(p.uri, p);
+      if (prior === undefined || (prior.binary === undefined && p.binary !== undefined)) plugins.set(key, p);
     }
   }
+  // a bare uri is the same plugin as a file's that holds it: it adds nothing once a file of that id is named
+  for (const [key, p] of plugins) if (p.binaryPath === undefined && [...plugins.values()].some((q) => q.uri === p.uri && q.binaryPath !== undefined)) plugins.delete(key);
   return refused.length > 0 ? { ok: false, refused } : { ok: true, plugins: [...plugins.values()] };
 }
 

package/src/qualify-options.ts

@@ -38,10 +38,10 @@ export const QUALIFY_OPTIONS: readonly QualifyOption[] = [
   {
     flag: "--grid",
     value: "hosts|full|cells",
-    describe: "the cells measured: hosts = each judged host's rate/quantum, then 512 at every rate; full = every rate at every quantum; or <rate>/<quantum>,...",
-    default: "hosts",
+    describe: "the cells measured: full = every rate at every quantum; hosts = each judged host's rate/quantum, then 512 at every rate (the fast option); or <rate>/<quantum>,...",
+    default: "full",
   },
-  { flag: "--grid-hosts", describe: "the same as --grid hosts" },
+  { flag: "--grid-hosts", describe: "the fast grid, the same as --grid hosts" },
   { flag: "--cells-per-plugin-budget", value: "n", describe: "measure at most the first n cells of the grid a plugin (0: every cell)", default: "0" },
   { flag: "--blocks", value: "n", describe: "blocks of the CLAP sweep a cell (the LV2 pass has a fixed shape)", default: String(CLAP_SWEEP_BLOCKS) },
   { flag: "--memory-limit", value: "size|off", describe: "the memory bound of every run (bytes, or with K, M, G); past it a cell is probe.oom", default: "half of the RAM" },