@openmixer/plugin-qualify 0.14.1 → 0.16.0

package/src/probe-runner.ts

@@ -17,9 +17,12 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 
 import { ClapQualifyError, clapQualifyTools, proberOffer, type RtSafetyDocument } from "./clap-qualify.js";
+import { locateNativeTool } from "./tool-paths.js";
 import type { HostProfile } from "./host-profiles.js";
-import { OPENMIXER_CONSOLE_PROFILE } 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 { judgeProbeOutput, judgmentVerdicts, type Judgment } from "./probe-judge.js";
 import { readProbeOutput, type ProbeOutput } from "./probe-output.js";
 import type { QualifyVerdict } from "./qualify-cli.js";
@@ -29,6 +32,7 @@ import {
   CLAP_SWEEP_FRAMES,
   LV2_HOSTING_BLOCK_FRAMES,
   LV2_HOSTING_TIMEOUT_S,
+  LV2_MEASURE_TOOL_NAME,
   PROBE_RUNNER_DEFAULT,
   PROBE_RUNNER_ENV,
 } from "./qualify-declarations.js";
@@ -67,6 +71,8 @@ export interface ProbeTargetOptions {
   readonly rates: readonly number[];
   /** Host extensions to offer beyond the prober's own (a CLAP run). */
   readonly offer?: readonly string[];
+  /** The wall clock the runner gives one run, in seconds; else the format's declared one. */
+  readonly wallS?: number;
   readonly run?: ProbeRun;
   readonly env?: Readonly<Record<string, string | undefined>>;
   readonly exists?: (path: string) => boolean;
@@ -74,7 +80,7 @@ export interface ProbeTargetOptions {
 
 /** The runner's arguments for a CLAP file; `child` is the prober the runner starts. */
 export function clapRunnerArgs(
-  options: { rates: readonly number[]; offer?: readonly string[]; out: string; log: string; child: string },
+  options: { rates: readonly number[]; offer?: readonly string[]; wallS?: number; out: string; log: string; child: string },
   binaryPath: string,
   id: string | undefined,
 ): string[] {
@@ -90,7 +96,7 @@ export function clapRunnerArgs(
     String(CLAP_SWEEP_BLOCKS),
     ...(options.offer === undefined || options.offer.length === 0 ? [] : ["--offer", options.offer.join(",")]),
     "--wall-s",
-    String(CLAP_QUALIFY_TIMEOUT_S),
+    String(options.wallS ?? CLAP_QUALIFY_TIMEOUT_S),
     "--out",
     options.out,
     "--log",
@@ -101,19 +107,19 @@ export function clapRunnerArgs(
 }
 
 /**
- * The runner's arguments for an LV2 plugin, named as `lv2:<uri>` and measured by the runner's own LV2
- * child. The runner of plugin-hostd 0.4.0 starts a CLAP prober only (the LV2 child, plugin-hostd#76, is in no release yet), so
- * against it this run ends with the runner's own refusal, which {@link runOne} reports.
+ * The runner's arguments for an LV2 plugin, named as `lv2:<uri>` and measured by `lv2_measure`: the one this run
+ * located when `child` names it, else the one the runner looks for where the packages install it.
  */
-export function lv2RunnerArgs(options: { rates: readonly number[]; out: string; log: string }, uri: string): string[] {
+export function lv2RunnerArgs(options: { rates: readonly number[]; wallS?: number; out: string; log: string; child?: string }, uri: string): string[] {
   return [
     "run",
+    ...(options.child === undefined ? [] : ["--child", options.child]),
     "--rates",
     options.rates.join(","),
     "--quantum",
     String(LV2_HOSTING_BLOCK_FRAMES),
     "--wall-s",
-    String(LV2_HOSTING_TIMEOUT_S),
+    String(options.wallS ?? LV2_HOSTING_TIMEOUT_S),
     "--out",
     options.out,
     "--log",
@@ -138,15 +144,20 @@ function runOne(target: PluginTarget, options: ProbeTargetOptions): ProbedTarget
     let args: string[];
     let runEnv: Record<string, string | undefined> = { ...env };
     let expectedId: string;
+    const wall = options.wallS === undefined ? {} : { wallS: options.wallS };
     if (target.format === "clap") {
       if (target.binaryPath === undefined) throw new ProbeRunnerError(`${target.uri}: no .clap to load; name the file or a directory holding it`);
       expectedId = target.uri.startsWith("urn:clap:") ? target.uri.slice("urn:clap:".length) : target.uri;
       const { tool: child, interposer } = clapQualifyTools(env, options.exists ?? existsSync);
-      args = clapRunnerArgs({ rates: options.rates, ...(options.offer === undefined ? {} : { offer: options.offer }), out, log, child }, target.binaryPath, expectedId);
+      args = clapRunnerArgs({ rates: options.rates, ...(options.offer === undefined ? {} : { offer: options.offer }), ...wall, out, log, child }, target.binaryPath, expectedId);
       runEnv = { ...env, LD_PRELOAD: interposer };
     } else {
       expectedId = target.uri;
-      args = lv2RunnerArgs({ rates: options.rates, out, log }, target.uri);
+      const child = locateNativeTool(LV2_MEASURE_TOOL_NAME, env, options.exists ?? existsSync).path;
+      args = lv2RunnerArgs(
+        { rates: options.rates, ...wall, out, log, ...(child === undefined ? {} : { child }) },
+        target.uri,
+      );
     }
     const r = (options.run ?? spawnRunner)(tool, args, runEnv);
     if (r.error !== undefined) {
@@ -199,16 +210,30 @@ export interface ProbePass {
  */
 export function qualifyTargets(
   targets: readonly PluginTarget[],
-  options: ProbeTargetOptions & { readonly profiles?: readonly HostProfile[] },
+  options: ProbeTargetOptions & { readonly profiles?: readonly HostProfile[]; readonly admissions?: AdmissionRuns },
 ): ProbePass {
   const profiles = options.profiles ?? [OPENMIXER_CONSOLE_PROFILE];
+  const admissionRuns = options.admissions ?? SPAWNED_ADMISSIONS;
   const runs: { bytes: Buffer; judgment: Judgment }[] = [];
   const verdicts: QualifyVerdict[] = [];
   const documents: RtSafetyDocument[] = [];
   const failures: { uri: string; problem: string }[] = [];
   for (const target of targets) {
     const byOffer = new Map<string, { offer: readonly string[]; profiles: HostProfile[] }>();
-    for (const profile of profiles) {
+    // the record carries the console's two tiers whatever hosts were asked about, so they are judged too
+    const tierProfiles = [IN_PROCESS_TIER_HOST, ISOLATED_TIER_HOST[target.format]]
+      .flatMap((id) => (id === undefined ? [] : [shippedHostProfile(id)]))
+      .filter((p): p is HostProfile => p !== undefined);
+    const judgedProfiles = [...profiles, ...tierProfiles.filter((t) => !profiles.some((p) => p.id === t.id))];
+    // an LV2 plugin is run under each measured host once, whichever probe output it is judged with
+    const admissions: Record<string, HostAdmission> = {};
+    if (target.format === "lv2") {
+      for (const profile of judgedProfiles) {
+        const host = admittedHostOf(profile);
+        if (host !== undefined) admissions[profile.id] = admitPlugin(host, target.uri, admissionRuns);
+      }
+    }
+    for (const profile of judgedProfiles) {
       const offer = target.format === "clap" ? (proberOffer(profile) ?? []) : [];
       const key = offer.join(",");
       const entry = byOffer.get(key) ?? { offer, profiles: [] };
@@ -222,7 +247,7 @@ export function qualifyTargets(
     try {
       for (const { offer, profiles: forOffer } of byOffer.values()) {
         const probed = probeTarget(target, { ...options, offer });
-        const judgment = judgeProbeOutput(probed.output, forOffer);
+        const judgment = judgeProbeOutput(probed.output, forOffer, { admissions });
         targetRuns.push({ bytes: probed.bytes, judgment });
         for (const v of judgmentVerdicts(judgment)) judged.set(v.host, v);
       }
@@ -230,7 +255,13 @@ export function qualifyTargets(
       if (!(e instanceof ProbeRunnerError) && !(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" });
+        // no probe output means no record, but a host that refused the plugin when it was run is still a measured refusal
+        const a = admissions[profile.id];
+        verdicts.push(
+          a !== undefined && a.measured && !a.admitted
+            ? { uri: target.uri, host: profile.id, measured: true, rating: "unsuitable", qualified: false, deciding: a.code ?? `${a.host}.not-admitted` }
+            : { uri: target.uri, host: profile.id, measured: false, rating: "unknown", qualified: false, deciding: "not-measured" },
+        );
       }
       continue;
     }

package/src/qualification-record.ts

@@ -13,12 +13,14 @@
  * Not yet in the record: the fingerprint of the descriptor's controls, since the descriptor is
  * written by the scan (stage 5) and plugin-qualify does not read one yet.
  */
-import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { mkdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 
+import type { Adjustment } from "./history-adjust.js";
 import type { Judgment, RecordReason } from "./probe-judge.js";
-import { sha256Hex, type ProbeGridPoint, type ProbeOutput } from "./probe-output.js";
+import { sha256Hex, PROBE_OK, type ProbeGridPoint, type ProbeOutput } from "./probe-output.js";
 import type { VoicesHeld } from "./measurement/format.js";
+import { writeFileWhole } from "./whole-file.js";
 
 export const QUALIFICATION_RECORD_SCHEMA = "plugin-qualify.qualification-record/1";
 
@@ -30,11 +32,89 @@ export interface RecordVerdict {
   readonly rating: string;
   readonly qualified: boolean;
   readonly hosting: "in-process" | "isolated";
+  /** `run` when the plugin was run under this host (`jalv`, `mod-host`), `declaration` when the verdict is what the profile's declaration makes of the probe output. */
+  readonly arm: "run" | "declaration";
   /** The code that decided it; absent for `suitable`. */
   readonly deciding?: string;
   readonly reasons: readonly RecordReason[];
 }
 
+/** One tier of the console as a verdict: the host it is judged under and whether the plugin qualified there. */
+export interface TierVerdict {
+  readonly host: string;
+  readonly measured: boolean;
+  readonly qualified: boolean;
+  readonly rating: string;
+  readonly deciding?: string;
+}
+
+/** The console's two tiers (what the console's roster offers): offered where the verdict qualified, dimmed with the reason when neither did. */
+export interface RecordTiers {
+  readonly inProcess?: TierVerdict;
+  readonly isolated?: TierVerdict;
+  readonly offeredOn: readonly ("in-process" | "isolated")[];
+  /** Why the plugin is offered on neither tier: the deciding codes, in-process first. */
+  readonly dimmed?: string;
+}
+
+/** The profile each format's isolated tier is judged under. */
+export const ISOLATED_TIER_HOST: Readonly<Record<string, string>> = { lv2: "mod-host", clap: "omx-clap-host" };
+export const IN_PROCESS_TIER_HOST = "openmixer-console";
+
+/** A latency or cost figure the run could not take: which one, at what rate and quantum, and the code that says why. */
+export interface UnmeasuredFigure {
+  readonly dimension: "latency" | "cost";
+  readonly rate?: number;
+  readonly quantum?: number;
+  /** The hosting code the run gave (`hosting.latency.unmeasured`), else the step's outcome code. */
+  readonly code: string;
+  /** The prober's own words, for a person; never what a reader classifies by. */
+  readonly detail?: string;
+}
+
+/**
+ * The figures the run could not take, from the steps that say so. A latency or cost step that did not end `probe.ok`
+ * leaves its figure out of the grid: this names the figure, so a grid point without a `latency` is never read as a plugin
+ * with none.
+ */
+export function unmeasuredFigures(output: ProbeOutput): readonly UnmeasuredFigure[] {
+  return output.steps
+    .filter((s) => (s.step === "latency" || s.step === "cost") && s.outcome !== PROBE_OK)
+    .map((s) => ({
+      dimension: s.step as "latency" | "cost",
+      ...(s.rate === undefined ? {} : { rate: s.rate }),
+      ...(s.quantum === undefined ? {} : { quantum: s.quantum }),
+      code: s.hostingCode ?? s.outcome,
+      ...(s.detail === undefined ? {} : { detail: s.detail }),
+    }));
+}
+
+/**
+ * What the running history made of the measured verdicts, for one host class: the second verdict beside the measured one.
+ * Written by `plugin-qualify adjust --history`; the measured `verdicts` above are never changed by it. A record without the
+ * block was never adjusted.
+ */
+export interface HistoryBlock {
+  /** The machine class of the history's lines, `arch/cores/clock`. */
+  readonly hostClass: string;
+  /** The history file as it was named. */
+  readonly file: string;
+  /** The UTC time the history was read at (ISO 8601). */
+  readonly at: string;
+  /** The line looked for: plugin-hostd's uri and the digest of the first file of the pin; absent when the record holds no whole pin. */
+  readonly key?: { readonly uri: string; readonly digest: string };
+  /** Whether the history holds a line of this plugin binary on this host class. */
+  readonly found: boolean;
+  /** The windows the line counts. */
+  readonly windows?: { readonly solo: number; readonly grouped: number };
+  /** What plugin-hostd's `history_get` would answer of the line. */
+  readonly summary?: { readonly crashed: boolean; readonly raisesXruns: boolean };
+  /** The keys of the line this tool does not know, as written. */
+  readonly unknownKeys?: Readonly<Record<string, string>>;
+  /** One per host profile adjusted: the measured pin verdict, the adjusted one, the move and the reason code. */
+  readonly verdicts: readonly ({ readonly host: string } & Adjustment)[];
+}
+
 export interface QualificationRecord {
   readonly schema: typeof QUALIFICATION_RECORD_SCHEMA;
   readonly plugin: { readonly format: string; readonly id: string; readonly name?: string };
@@ -42,6 +122,7 @@ export interface QualificationRecord {
   readonly testedVersion?: string;
   readonly binary: ProbeOutput["binary"];
   readonly verdicts: readonly RecordVerdict[];
+  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 {
     readonly host: string;
@@ -50,11 +131,25 @@ export interface QualificationRecord {
     readonly voices?: VoicesHeld;
     readonly reasons: readonly RecordReason[];
   }[];
-  /** The figures as measured, per rate and quantum. */
-  readonly measurements: { readonly grid: readonly ProbeGridPoint[]; readonly behaviour?: Readonly<Record<string, unknown>> };
+  /**
+   * The figures as measured, per rate and quantum: the same fields whichever format the plugin is (`latency`
+   * {declaredFrames, measuredFrames}, `cost`, `rtSafety`, `noteSweep`), and the figures the run could not take, named.
+   */
+  readonly measurements: {
+    readonly grid: readonly ProbeGridPoint[];
+    readonly behaviour?: Readonly<Record<string, unknown>>;
+    readonly unmeasured?: readonly UnmeasuredFigure[];
+  };
+  /**
+   * What the run that wrote this record did not measure, each with the code a verdict reads for it: the quick
+   * qualification of `plugin-qualify-sync` takes no soak, and says so here rather than leave it unstated.
+   */
+  readonly notMeasured?: readonly NotMeasured[];
   /** Who measured and when. */
   readonly tool: Readonly<Record<string, string>>;
   readonly measuredAt: string;
+  /** The second verdict, per host class of the history that was read; absent until `adjust --history` has run. */
+  readonly history?: readonly HistoryBlock[];
   /** The probe output this record judged. */
   readonly probe: {
     readonly file: string;
@@ -70,6 +165,12 @@ export interface QualificationRecord {
   };
 }
 
+/** One dimension a run did not measure, and the code that says so. */
+export interface NotMeasured {
+  readonly dimension: string;
+  readonly code: string;
+}
+
 const safe = (text: string): string => text.replace(/[^A-Za-z0-9._-]/g, "_");
 
 /** `<id>@<version>-<sha256 first 12>.<offer>`: one binary and one offer, whatever the run. */
@@ -80,7 +181,33 @@ export function qualificationBaseName(output: ProbeOutput): string {
 export const recordFileName = (output: ProbeOutput): string => `${qualificationBaseName(output)}.qualification.json`;
 export const probeCopyFileName = (output: ProbeOutput): string => `${qualificationBaseName(output)}.probe.json`;
 
-export function buildQualificationRecord(judgment: Judgment, copy: { file: string; sha256: string; bytes: number }): QualificationRecord {
+function tierOf(judgment: Judgment, host: string | undefined): TierVerdict | undefined {
+  const v = judgment.hosts.find((h) => h.verdict.host === host)?.verdict;
+  if (v === undefined) return undefined;
+  return { host: v.host, measured: v.measured, qualified: v.qualified, rating: v.rating, ...(v.deciding === undefined ? {} : { deciding: v.deciding }) };
+}
+
+/** The console's two tiers from the verdicts the judgment holds. A tier no profile judged is absent, and is not offered. */
+export function tiersOf(judgment: Judgment): RecordTiers {
+  const inProcess = tierOf(judgment, IN_PROCESS_TIER_HOST);
+  const isolated = tierOf(judgment, ISOLATED_TIER_HOST[judgment.output.plugin.format]);
+  const offeredOn: ("in-process" | "isolated")[] = [];
+  if (inProcess?.qualified === true) offeredOn.push("in-process");
+  if (isolated?.qualified === true) offeredOn.push("isolated");
+  const why = [inProcess, isolated].flatMap((t) => (t === undefined ? [] : [`${t.host}: ${t.deciding ?? t.rating}`]));
+  return {
+    ...(inProcess === undefined ? {} : { inProcess }),
+    ...(isolated === undefined ? {} : { isolated }),
+    offeredOn,
+    ...(offeredOn.length === 0 ? { dimmed: why.length === 0 ? "no tier was judged" : why.join("; ") } : {}),
+  };
+}
+
+export function buildQualificationRecord(
+  judgment: Judgment,
+  copy: { file: string; sha256: string; bytes: number },
+  notMeasured: readonly NotMeasured[] = [],
+): QualificationRecord {
   const o = judgment.output;
   return {
     schema: QUALIFICATION_RECORD_SCHEMA,
@@ -93,11 +220,18 @@ export function buildQualificationRecord(judgment: Judgment, copy: { file: strin
       rating: h.verdict.rating,
       qualified: h.verdict.qualified,
       hosting: h.hosting,
+      arm: h.arm,
       ...(h.verdict.deciding === undefined ? {} : { deciding: h.verdict.deciding }),
       reasons: h.reasons,
     })),
+    tiers: tiersOf(judgment),
     cost: judgment.hosts.map((h) => ({ host: h.verdict.host, ...h.cost })),
-    measurements: { grid: o.grid, ...(o.behaviour === undefined ? {} : { behaviour: o.behaviour }) },
+    measurements: {
+      grid: o.grid,
+      ...(o.behaviour === undefined ? {} : { behaviour: o.behaviour }),
+      ...(unmeasuredFigures(o).length === 0 ? {} : { unmeasured: unmeasuredFigures(o) }),
+    },
+    ...(notMeasured.length === 0 ? {} : { notMeasured }),
     tool: o.run.tools,
     measuredAt: o.run.startedAt,
     probe: {
@@ -119,11 +253,9 @@ export function qualificationRecordOf(probeBytes: Uint8Array, judgment: Judgment
   return buildQualificationRecord(judgment, { file: probeCopyFileName(judgment.output), sha256: sha256Hex(probeBytes), bytes: probeBytes.length });
 }
 
-/** A file whole or not at all: written beside its name and renamed over it. */
-function writeWhole(path: string, bytes: string | Uint8Array): void {
-  const pending = `${path}.new`;
-  writeFileSync(pending, bytes);
-  renameSync(pending, path);
+/** The record rewritten whole or not at all, with its `history` block; nothing else in it is changed by the caller. */
+export function rewriteRecord(path: string, record: QualificationRecord): void {
+  writeFileWhole(path, `${JSON.stringify(record, null, 2)}\n`);
 }
 
 export interface WrittenQualification {
@@ -137,13 +269,40 @@ export interface WrittenQualification {
  * record names the SHA-256 of the copy as it is on disk, read back, so a record never names bytes that
  * are not there. A rescan of the same binary and offer replaces both.
  */
-export function writeQualification(dir: string, probeBytes: Uint8Array, judgment: Judgment): WrittenQualification {
+export function writeQualification(
+  dir: string,
+  probeBytes: Uint8Array,
+  judgment: Judgment,
+  notMeasured: readonly NotMeasured[] = [],
+): WrittenQualification {
   mkdirSync(dir, { recursive: true });
   const probePath = join(dir, probeCopyFileName(judgment.output));
-  writeWhole(probePath, probeBytes);
+  writeFileWhole(probePath, probeBytes);
   const copy = readFileSync(probePath);
-  const record = buildQualificationRecord(judgment, { file: probeCopyFileName(judgment.output), sha256: sha256Hex(copy), bytes: copy.length });
+  const record = buildQualificationRecord(judgment, { file: probeCopyFileName(judgment.output), sha256: sha256Hex(copy), bytes: copy.length }, notMeasured);
   const recordPath = join(dir, recordFileName(judgment.output));
-  writeWhole(recordPath, `${JSON.stringify(record, null, 2)}\n`);
+  writeFileWhole(recordPath, `${JSON.stringify(record, null, 2)}\n`);
   return { recordPath, probePath, record };
 }
+
+/**
+ * Runs that name the same binary and offer share one record file (a CLAP judged with and without the extra extensions
+ * offered): their verdicts become one record over the first run's probe output, so the second is never written over the first.
+ */
+export function mergeRunsByRecord<T extends { readonly bytes: Uint8Array; readonly judgment: Judgment }>(runs: readonly T[]): { bytes: Uint8Array; judgment: Judgment }[] {
+  const byName = new Map<string, { bytes: Uint8Array; judgment: Judgment }>();
+  for (const r of runs) {
+    const name = qualificationBaseName(r.judgment.output);
+    const first = byName.get(name);
+    byName.set(
+      name,
+      first === undefined
+        ? r
+        : {
+            bytes: first.bytes,
+            judgment: { ...first.judgment, hosts: [...first.judgment.hosts, ...r.judgment.hosts], documents: [...first.judgment.documents, ...r.judgment.documents] },
+          },
+    );
+  }
+  return [...byName.values()];
+}

package/src/qualify-cli.ts

@@ -31,7 +31,6 @@ export interface QualifyArgs {
   readonly pins?: string;
   readonly format: OutputFormat;
   readonly isolate: boolean;
-  readonly hostSweep: boolean;
   /** `--host-profile` specs (a shipped id or a profile file), in order, once each. */
   readonly hostProfiles: readonly string[];
   readonly help: boolean;
@@ -99,7 +98,6 @@ export function parseQualifyArgs(argv: readonly string[]): ParseResult {
       ...(pins === undefined ? {} : { pins }),
       format: format as OutputFormat,
       isolate: seen.has("--isolate"),
-      hostSweep: !seen.has("--no-host-sweep"),
       hostProfiles,
       help,
     },
@@ -116,9 +114,8 @@ export function helpText(): string {
     "plugin-qualify — qualify audio plugins for real-time hosting",
     "",
     "  plugin-qualify <uri|bundle-path>...   exactly the named plugins; a .lv2 bundle = every plugin in it",
-    "  plugin-qualify --all                  every CLAP plugin on CLAP_PATH, then ~/.clap, then /usr/lib/clap;",
-    "                                        refuses (exit 2) when LV2 bundles are on the LV2 path (LV2_PATH),",
-    "                                        whose plugins --all does not enumerate: name them instead",
+    "  plugin-qualify --all                  every LV2 plugin of the bundles on the LV2 path (LV2_PATH), then every CLAP plugin on",
+    "                                        CLAP_PATH, then ~/.clap, then /usr/lib/clap; with --out, one record each",
     "",
     ...rows,
     "",

package/src/qualify-declarations.ts

@@ -165,7 +165,14 @@ export const DESCRIPTOR_HASH_PREFIX = 12;
  */
 export const DESCRIPTOR_SCHEMA_ENV = "OMX_CONTRACT_SCHEMA";
 export const DESCRIPTOR_SCHEMA_INSTALLED = "/usr/share/omx-contract/omx-contract.schema.json";
-export const DESCRIPTOR_SCHEMA_FLOOR = ">= 3.0.0";
+export const DESCRIPTOR_SCHEMA_FLOOR = ">= 3.4.0";
+
+/**
+ * Two ids that `_safe` maps onto the same characters (`a b` and `a_b`) would otherwise name the
+ * same file at the same version. The id whose safe form differs from the raw id carries this many
+ * hex digits of the raw id's SHA-256 as well, so the two no longer collide.
+ */
+export const DESCRIPTOR_ID_HASH_PREFIX = 8;
 
 /**
  * Why a scanned descriptor is not written. A file the schema refuses is omx-contract's own
@@ -173,6 +180,7 @@ export const DESCRIPTOR_SCHEMA_FLOOR = ">= 3.0.0";
  */
 export const DESCRIPTOR_CODE_SCHEMA = "contract.file.invalid";
 export const DESCRIPTOR_CODE_SCHEMA_MISSING = "qualify.descriptor.schema-missing";
+export const DESCRIPTOR_CODE_SCHEMA_FLOOR = "qualify.descriptor.schema-floor";
 export const DESCRIPTOR_CODE_BINARY_UNHASHED = "qualify.descriptor.binary-unhashed";
 export const DESCRIPTOR_CODE_DIR_UNWRITABLE = "qualify.descriptor.dir-unwritable";
 

package/src/qualify-options.ts

@@ -32,13 +32,12 @@ export interface QualifyOption {
 }
 
 export const QUALIFY_OPTIONS: readonly QualifyOption[] = [
-  { flag: "--all", describe: "every CLAP plugin on the CLAP search path; refuses when LV2 bundles are on the LV2 path" },
+  { flag: "--all", describe: "every LV2 plugin on the LV2 search path and every CLAP plugin on the CLAP search path; with --out, one record each" },
   { flag: "--rates", value: "list", describe: "sample rates to measure at, comma-separated", default: QUALIFY_RATES.join(",") },
   { flag: "--quanta", value: "list", describe: "quanta (frames) to rate cost at, comma-separated", default: QUALIFY_QUANTA.join(",") },
   { flag: "--out", value: "dir", describe: "write one interchange JSON document per run into this directory" },
   { flag: "--format", value: OUTPUT_FORMATS.join("|"), describe: "json = the verdicts as JSON; text = plugin, verdict, deciding reason", default: "text" },
   { flag: "--isolate", describe: "a fresh worker per plugin, so a crash or hang takes only that plugin" },
-  { flag: "--no-host-sweep", describe: "offline lilv measurement only; no mod-host hosting sweep" },
   {
     flag: "--host-profile",
     value: "file|id",