@openmixer/plugin-qualify 0.12.0 → 0.13.0

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

@@ -109,6 +109,17 @@
       "clap.params",
       "clap.state",
       "clap.thread-check",
+      "clap.note-ports",
+      "clap.note-name",
+      "clap.voice-info",
+      "clap.event-registry",
+      "clap.timer-support",
+      "clap.posix-fd-support",
+      "clap.thread-pool",
+      "clap.tail",
+      "clap.surround/4",
+      "clap.ambisonic/3",
+      "clap.audio-ports-config",
       "clap.preset-load/2",
       "clap.track-info/1",
       "clap.remote-controls/2"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openmixer/plugin-qualify",
-  "version": "0.12.0",
+  "version": "0.13.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",
@@ -96,6 +96,6 @@
     "provenance": true
   },
   "dependencies": {
-    "@openmixer/omx-contract": "^2.16.0"
+    "@openmixer/omx-contract": "^3.0.0"
   }
 }

package/src/host-profiles.ts

@@ -42,8 +42,7 @@ export const OMX_INPROCESS_FEATURES: readonly string[] = [
  * than on the desk. The list's home is the CLAP library — libomx-clap-core's own
  * `clap_host_extensions.h`, what its host object offers — and this is its mirror, held equal to the
  * header at the pinned omx-clap-host (by the console's conformance test), so the verdict never
- * promises more or less than the host provides. Nothing else: no `gui`, no `timer-support`, no
- * `posix-fd-support`, no `thread-pool`.
+ * promises more or less than the host provides. Nothing else: no `gui`.
  */
 export const OMX_CLAP_HOST_EXTENSIONS: readonly string[] = [
   "clap.log",
@@ -52,6 +51,17 @@ export const OMX_CLAP_HOST_EXTENSIONS: readonly string[] = [
   "clap.params",
   "clap.audio-ports",
   "clap.state",
+  "clap.note-ports",
+  "clap.note-name",
+  "clap.voice-info",
+  "clap.event-registry",
+  "clap.timer-support",
+  "clap.posix-fd-support",
+  "clap.thread-pool",
+  "clap.tail",
+  "clap.surround/4",
+  "clap.ambisonic/3",
+  "clap.audio-ports-config",
 ];
 
 /**

package/src/hosting-codes.ts

@@ -1,82 +1,187 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 // Copyright (C) 2026 Pau Aliagas <linuxnow@gmail.com>
 /**
- * The hosting verdict's message codes. Codes, never prose: the
- * surface renders the operator's locale.
+ * The hosting verdict's message codes. Codes, never prose: the surface renders the operator's
+ * locale.
  *
- * A UNION list file: `.gitattributes` marks it
- * `merge=union`, so two lanes that each add a code merge with both kept. Only the table lives
- * here, one `key: 'code',` per line, with keys and codes unique; the registry-hotspots gate
- * refuses anything else.
+ * omx-clap-core declares every hosting code now (the contract split moved `data/hosting/*.json`
+ * there, byte for byte): one `HOSTING_<DIMENSION>_CODES` table per dimension, rendered into the
+ * TypeScript modules its package installs under `pkg-config --variable=tsdir omx-clap-core`
+ * (BUILDING.md) — `omx-clap-core-vocabulary.js` for the dimensions carried from omx-contract,
+ * `omx-clap-core-hosting.js` for `hosting.idle.*`, its own (both with a `.d.ts`). {@link
+ * HOSTING_CODE} is those tables flattened into one `key: code` map, loaded at import: a code
+ * neither module declares cannot be named here, and a dimension either adds arrives without an
+ * edit.
  */
-export const HOSTING_CODE = {
-  stabilitySoaked: 'hosting.stability.soaked',
-  stabilityCrashedAttributed: 'hosting.stability.crashed-attributed-plugin',
-  stabilityCrashedLive: 'hosting.stability.crashed-live-on-this-rig',
-  stabilityBelowFloor: 'hosting.stability.cycles-below-floor',
-  stabilityUnsoaked: 'hosting.stability.unsoaked',
-  stabilitySoakFailedAtRate: 'hosting.stability.soak-failed-at-rate',
-  stabilityUnmeasured: 'hosting.stability.unmeasured',
-  stabilityCrashUnattributed: 'hosting.stability.crash-unattributed',
-  stabilitySpawnsThreads: 'hosting.stability.spawns-threads',
-  stabilityLinksGuiToolkit: 'hosting.stability.links-gui-toolkit',
-  rtSafetyClean: 'hosting.rt-safety.clean-under-sweep',
-  rtSafetyViolations: 'hosting.rt-safety.violations-in-run',
-  rtSafetyUnmeasured: 'hosting.rt-safety.unmeasured',
-  rtSafetyNotReproducible: 'hosting.rt-safety.not-reproducible',
-  // The note sweep: an instrument played under the interposer, a count of its own.
-  rtSafetyNotesClean: 'hosting.rt-safety.clean-under-notes',
-  rtSafetyNotesViolations: 'hosting.rt-safety.violations-under-notes',
-  rtSafetyNotesUnmeasured: 'hosting.rt-safety.notes-unmeasured',
-  featuresProvided: 'hosting.features.all-provided',
-  featuresMissing: 'hosting.features.required-not-provided',
-  featuresDisqualifying: 'hosting.features.host-not-provided',
-  featuresCv: 'hosting.features.cv-ports',
-  featuresMidiIn: 'hosting.features.midi-in-fed-empty',
-  featuresUnscanned: 'hosting.features.scan-predates-field',
-  costWithinCeiling: 'hosting.cost.within-ceiling',
-  costAboveCeiling: 'hosting.cost.above-ceiling',
-  costSpiky: 'hosting.cost.spiky-tail',
-  costUnmeasured: 'hosting.cost.unmeasured-at-rate-and-quantum',
-  costFieldsMissing: 'hosting.cost.fields-missing',
-  latencyResolved: 'hosting.latency.resolved',
-  latencyUnmeasured: 'hosting.latency.unmeasured',
-  latencyNonconforming: 'hosting.latency.nonconforming',
-  latencyParameterDependent: 'hosting.latency.parameter-dependent',
-  topologyMatched: 'hosting.topology.matched',
-  topologyNoAudioInput: 'hosting.topology.no-audio-input',
-  topologyNoAudioOutput: 'hosting.topology.no-audio-output',
-  topologyExtraInputs: 'hosting.topology.extra-inputs-fed-silence',
-  topologyInstrument: 'hosting.topology.instrument',
-  // The CLAP arm: the SAME dimensions fed from CLAP facts,
-  // minted here where the LV2 table has no code for the fact.
-  topologyWiderThanStrip: 'hosting.topology.wider-than-strip',
-  clapLatencyMismatch: 'hosting.clap.latency-mismatch',
-  clapNotAudioEffect: 'hosting.clap.not-audio-effect',
-  clapHeadlessFailed: 'hosting.clap.headless-failed',
-  clapNoteInput: 'hosting.clap.note-input',
-  clapThreadViolation: 'hosting.clap.thread-violation',
-  clapProcessError: 'hosting.clap.process-error',
-  clapUnqualified: 'hosting.clap.unqualified',
-  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',
-  integrityLayoutMismatch: 'hosting.integrity.layout-mismatch',
-  overrideIsolated: 'hosting.override.curator-isolated',
-  hostProvenanceDiffers: 'hosting.provenance.host-differs',
-  sweepControlDidNotFire: 'hosting.provenance.sweep-control-did-not-fire',
-  // The five REALISED reasons. Everything above answers what a plugin EARNED; these answer
-  // what the console DID with that, and the difference between the two is the operator's
-  // whole question when a slot is not on the fast path.
-  disabled: 'hosting.disabled',
-  unjudged: 'hosting.unjudged',
-  noRealisation: 'hosting.no-realisation',
-  realisedInProcess: 'hosting.realised.in-process',
-  // A plugin LINKED into the engine (the static-link registry) runs in-process without a
-  // verdict: the library's oracles are its proof.
-  linked: 'hosting.linked',
-} as const;
+import { execFileSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+/** The two TypeScript modules omx-clap-core's `tsdir` carries, each a `HOSTING_<DIMENSION>_CODES` source. */
+const CLAP_CORE_TS_MODULES = ["omx-clap-core-vocabulary.js", "omx-clap-core-hosting.js"] as const;
+
+/** This package's own root, resolved from this module so it follows wherever it is installed. */
+const PACKAGE_ROOT = fileURLToPath(new URL("..", import.meta.url));
+
+/** `native/fetch-deps.sh`'s own checkout of omx-clap-core, for a build with no omx-clap-core-devel installed. */
+const DEPS_TS_DIR = join(PACKAGE_ROOT, "native/deps/omx-clap-core/ts");
+
+/** Where `make install` of omx-clap-host puts them (BUILDING.md), for a run with no `pkg-config` binary at all. */
+const DEFAULT_SYSTEM_TS_DIR = "/usr/share/omx-clap-core/ts";
+
+/** `pkg-config --variable=tsdir omx-clap-core`, or `undefined` where pkg-config or the package is absent. */
+function pkgConfigTsDir(env: Readonly<Record<string, string | undefined>>): string | undefined {
+  try {
+    const out = execFileSync(env.PKG_CONFIG ?? "pkg-config", ["--variable=tsdir", "omx-clap-core"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+    }).trim();
+    return out === "" ? undefined : out;
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * Where omx-clap-core's TypeScript modules are looked for, in order: `OMX_CLAP_CORE_TSDIR` when
+ * set (and only that), else `pkg-config --variable=tsdir omx-clap-core`, else the checkout
+ * `native/fetch-deps.sh` stages, else the path `make install` of omx-clap-host uses by default —
+ * a packaged plugin-qualify's runtime has no `pkg-config` binary to ask.
+ */
+export function clapCoreTsDirCandidates(env: Readonly<Record<string, string | undefined>> = process.env): readonly string[] {
+  const set = env.OMX_CLAP_CORE_TSDIR;
+  if (set !== undefined && set !== "") return [set];
+  const fromPkgConfig = pkgConfigTsDir(env);
+  return [...(fromPkgConfig === undefined ? [] : [fromPkgConfig]), DEPS_TS_DIR, DEFAULT_SYSTEM_TS_DIR];
+}
+
+function locateClapCoreTsDir(): string {
+  const candidates = clapCoreTsDirCandidates();
+  const dir = candidates.find((d) => CLAP_CORE_TS_MODULES.every((m) => existsSync(join(d, m))));
+  if (dir === undefined) {
+    throw new Error(
+      `omx-clap-core's TypeScript modules (${CLAP_CORE_TS_MODULES.join(", ")}) were not found in any of: ` +
+        `${candidates.join(", ")}. Install omx-clap-core-devel (pkg-config omx-clap-core), set ` +
+        "OMX_CLAP_CORE_TSDIR to its tsdir, or run native/fetch-deps.sh.",
+    );
+  }
+  return dir;
+}
+
+/** True for an export name that is one of omx-clap-core's hosting tables. */
+export function isHostingTableName(name: string): boolean {
+  return /^HOSTING_[A-Z0-9_]+_CODES$/.test(name);
+}
+
+type HostingEntries = Record<string, { readonly code: string }>;
+
+async function loadHostingTables(): Promise<Record<string, HostingEntries>> {
+  const dir = locateClapCoreTsDir();
+  const tables: Record<string, HostingEntries> = {};
+  for (const name of CLAP_CORE_TS_MODULES) {
+    // The modules are self-contained ES modules in a directory with no package.json: Node 18 reads such a .js as
+    // CommonJS and refuses `export`, so the source is imported as a data: module, which is a module on every Node.
+    const source = readFileSync(join(dir, name), "utf8");
+    const mod: Record<string, unknown> = await import(`data:text/javascript;base64,${Buffer.from(source).toString("base64")}`);
+    for (const [exportName, table] of Object.entries(mod)) {
+      if (isHostingTableName(exportName)) tables[exportName] = table as HostingEntries;
+    }
+  }
+  return tables;
+}
+
+function flatten(tables: Record<string, HostingEntries>): HostingCodeTable {
+  const table: Record<string, string> = {};
+  for (const [name, entries] of Object.entries(tables)) {
+    for (const [key, entry] of Object.entries(entries)) {
+      if (key in table) throw new Error(`omx-clap-core declares the hosting key ${key} twice (${name})`);
+      table[key] = entry.code;
+    }
+  }
+  return Object.freeze(table) as unknown as HostingCodeTable;
+}
+
+/**
+ * omx-clap-core's hosting codes, by key, across its two TypeScript modules — hand-kept here
+ * (not derived from a static import: the source is a runtime-resolved install directory, not an
+ * npm dependency) and held to the real modules by
+ * `src/contract-vocabulary-conformance.test.ts`, which turns red on any drift either way.
+ */
+export interface HostingCodeTable {
+  readonly clapExtensionsNotCovered: "hosting.clap.extensions-not-covered";
+  readonly clapFormatNotHosted: "hosting.clap.format-not-hosted";
+  readonly clapHeadlessFailed: "hosting.clap.headless-failed";
+  readonly clapLatencyMismatch: "hosting.clap.latency-mismatch";
+  readonly clapNoteInput: "hosting.clap.note-input";
+  readonly clapProcessError: "hosting.clap.process-error";
+  readonly clapThreadViolation: "hosting.clap.thread-violation";
+  readonly clapUnqualified: "hosting.clap.unqualified";
+  readonly costAboveCeiling: "hosting.cost.above-ceiling";
+  readonly costFieldsMissing: "hosting.cost.fields-missing";
+  readonly costSpiky: "hosting.cost.spiky-tail";
+  readonly costUnmeasured: "hosting.cost.unmeasured-at-rate-and-quantum";
+  readonly costWithinCeiling: "hosting.cost.within-ceiling";
+  readonly featuresAtomInUnfed: "hosting.features.atom-in-unfed";
+  readonly featuresDisqualifying: "hosting.features.host-not-provided";
+  readonly featuresMidiIn: "hosting.features.midi-in-fed-empty";
+  readonly featuresMissing: "hosting.features.missing";
+  readonly featuresPortsUnreadable: "hosting.features.ports-unreadable";
+  readonly featuresProvided: "hosting.features.all-provided";
+  readonly featuresUnscanned: "hosting.features.scan-predates-field";
+  readonly idleHoldRefused: "hosting.idle.hold-refused";
+  readonly latencyNonconforming: "hosting.latency.nonconforming";
+  readonly latencyParameterDependent: "hosting.latency.parameter-dependent";
+  readonly latencyResolved: "hosting.latency.resolved";
+  readonly latencyUnmeasured: "hosting.latency.unmeasured";
+  readonly outputNonFinite: "hosting.output.non-finite";
+  readonly overrideIsolated: "hosting.override.curator-isolated";
+  readonly patchBusy: "hosting.patch.busy";
+  readonly patchNotWritable: "hosting.patch.not-writable";
+  readonly patchTooLarge: "hosting.patch.too-large";
+  readonly presetNotFound: "hosting.preset.not-found";
+  readonly hostProvenanceDiffers: "hosting.provenance.host-differs";
+  readonly sweepControlDidNotFire: "hosting.provenance.sweep-control-did-not-fire";
+  readonly disabled: "hosting.disabled";
+  readonly linked: "hosting.linked";
+  readonly noRealisation: "hosting.no-realisation";
+  readonly realisedInProcess: "hosting.realised.in-process";
+  readonly unjudged: "hosting.unjudged";
+  readonly rtSafetyClean: "hosting.rt-safety.clean-under-sweep";
+  readonly rtSafetyNotReproducible: "hosting.rt-safety.not-reproducible";
+  readonly rtSafetyNotesClean: "hosting.rt-safety.clean-under-notes";
+  readonly rtSafetyNotesUnmeasured: "hosting.rt-safety.notes-unmeasured";
+  readonly rtSafetyNotesViolations: "hosting.rt-safety.violations-under-notes";
+  readonly rtSafetyUnmeasured: "hosting.rt-safety.unmeasured";
+  readonly rtSafetyViolations: "hosting.rt-safety.violations-in-run";
+  readonly stabilityBelowFloor: "hosting.stability.cycles-below-floor";
+  readonly stabilityCrashUnattributed: "hosting.stability.crash-unattributed";
+  readonly stabilityCrashedAttributed: "hosting.stability.crashed-attributed-plugin";
+  readonly stabilityCrashedLive: "hosting.stability.crashed-live-on-this-rig";
+  readonly stabilityLinksGuiToolkit: "hosting.stability.links-gui-toolkit";
+  readonly stabilitySoakFailedAtRate: "hosting.stability.soak-failed-at-rate";
+  readonly stabilitySoaked: "hosting.stability.soaked";
+  readonly stabilitySpawnsThreads: "hosting.stability.spawns-threads";
+  readonly stabilityUnmeasured: "hosting.stability.unmeasured";
+  readonly stabilityUnsoaked: "hosting.stability.unsoaked";
+  readonly stateNotACopy: "hosting.state.not-a-copy";
+  readonly statePathOnAudio: "hosting.state.path-on-audio";
+  readonly statePathOutside: "hosting.state.path-outside";
+  readonly statePathSymlink: "hosting.state.path-symlink";
+  readonly statePathTooLong: "hosting.state.path-too-long";
+  readonly statePathUnmakeable: "hosting.state.path-unmakeable";
+  readonly stateUnreadable: "hosting.state.unreadable";
+  readonly topologyAmbisonicConfig: "hosting.topology.ambisonic-config";
+  readonly topologyChannelMapUnknown: "hosting.topology.channel-map-unknown";
+  readonly topologyInstrument: "hosting.topology.instrument";
+  readonly topologyMatched: "hosting.topology.matched";
+  readonly topologyNoAudioInput: "hosting.topology.no-audio-input";
+  readonly topologyNoAudioOutput: "hosting.topology.no-audio-output";
+  readonly topologyPortTooWide: "hosting.topology.port-too-wide";
+  readonly topologyPortWithoutChannels: "hosting.topology.port-without-channels";
+  readonly topologyTooManyPorts: "hosting.topology.too-many-ports";
+  readonly topologyWiderThanStrip: "hosting.topology.wider-than-strip";
+  readonly workerNonconforming: "hosting.worker.nonconforming";
+}
+
+export const HOSTING_CODE: HostingCodeTable = flatten(await loadHostingTables());

package/src/hosting-suitability.ts

@@ -148,12 +148,11 @@ export type HostingCode = (typeof HOSTING_CODE)[keyof typeof HOSTING_CODE];
  */
 export const CLAP_CORE_REFUSALS = {
   headlessFailed: "clapHeadlessFailed",
-  notAudioEffect: "clapNotAudioEffect",
   noteInput: "clapNoteInput",
   noAudioInput: "topologyNoAudioInput",
   noAudioOutput: "topologyNoAudioOutput",
   widerThanStrip: "topologyWiderThanStrip",
-  extraInputs: "topologyExtraInputs",
+  tooManyPorts: "topologyTooManyPorts",
   crashedLive: "stabilityCrashedLive",
   outputNonFinite: "outputNonFinite",
 } as const satisfies Record<string, keyof typeof HOSTING_CODE>;
@@ -164,12 +163,11 @@ export const CLAP_CORE_REFUSALS = {
  * refusal so the renderer holds no prose. A refusal without a line renders bare.
  */
 export const CLAP_CORE_REFUSAL_DESCRIPTIONS: { readonly [K in keyof typeof CLAP_CORE_REFUSALS]?: string } = {
-  notAudioEffect: "the plugin is not an audio effect",
   noteInput: "the plugin declares a note input the configuration refuses",
   noAudioInput: "the plugin has no audio input",
   noAudioOutput: "the plugin has no audio output",
   widerThanStrip: "the plugin is wider than the strip",
-  extraInputs: "the plugin has extra inputs, fed silence",
+  tooManyPorts: "the plugin has more ports than the auxiliary limit allows",
   crashedLive: "the plugin crashed live on this rig",
   outputNonFinite: "the plugin produced non-finite output",
 };
@@ -696,9 +694,6 @@ export function featureReasons(
         }),
       );
     }
-    if ((features.cvPorts ?? 0) > 0) {
-      out.push(reason("features", "objective", "unsuitable", HOSTING_CODE.featuresCv));
-    }
   }
   if (descriptor.hasMidiIn && !instruments) {
     out.push(reason("features", "objective", "conditional", HOSTING_CODE.featuresMidiIn));
@@ -821,7 +816,7 @@ export function hostingTopologyReasons(
     ];
   }
   return [
-    reason("topology", "objective", "conditional", HOSTING_CODE.topologyExtraInputs, { ins, outs }),
+    reason("topology", "objective", "conditional", HOSTING_CODE.topologyTooManyPorts, { ins, outs }),
   ];
 }
 
@@ -845,7 +840,7 @@ export function clapTopologyReasons(clap: PluginClapMeasurement | undefined, ins
     return [reason("topology", "objective", "unsuitable", HOSTING_CODE.topologyWiderThanStrip, { ins, outs })];
   }
   if (clap.sidechainInputs > 0) {
-    return [reason("topology", "objective", "unsuitable", HOSTING_CODE.topologyExtraInputs, { ins, outs, sidechains: clap.sidechainInputs })];
+    return [reason("topology", "objective", "unsuitable", HOSTING_CODE.topologyTooManyPorts, { ins, outs, sidechains: clap.sidechainInputs })];
   }
   return [reason("topology", "objective", "suitable", HOSTING_CODE.topologyMatched, { ins, outs })];
 }
@@ -899,11 +894,6 @@ export function clapFeatureReasons(
   }
   const out: HostingReason[] = [];
   const offered = profile.clapExtensions;
-  const kindHosted =
-    clap.features.includes(CLAP_FEATURE_AUDIO_EFFECT) || (profile.instruments && clap.features.includes(CLAP_FEATURE_INSTRUMENT));
-  if (!kindHosted) {
-    out.push(reason("features", "objective", "unsuitable", HOSTING_CODE.clapNotAudioEffect, { features: clap.features.join(" ") }));
-  }
   if (!clap.headlessOk) {
     out.push(reason("features", "objective", "unsuitable", HOSTING_CODE.clapHeadlessFailed));
   } else {

package/src/measurement/cli.ts

@@ -99,7 +99,7 @@ export interface MeasureOptions {
  * them: the provider's kinds (`--features`), its buf-size declarations (`--block-declares`) and its log
  * modes (`--log`). A conformance test reads both.
  */
-export const LV2_FEATURE_KINDS = ["map", "unmap", "options", "bounded", "worker", "default-state", "log"] as const;
+export const LV2_FEATURE_KINDS = ["map", "unmap", "options", "bounded", "worker", "default-state", "log", "rtmempool"] as const;
 export const LV2_BLOCK_DECLARATIONS = ["bounded", "fixed", "pow2"] as const;
 export const LV2_LOG_MODES = ["silent", "route", "capture"] as const;
 

package/src/measurement/format.ts

@@ -147,7 +147,7 @@ export interface MeasurementHost {
 
 /** How the latency figures in this document were taken. */
 export interface LatencyMethod {
-  /** A {@link ../vocabulary.METHOD_TERMS} code — `impulse-onset` or `declared-port`. */
+  /** A {@link ../vocabulary.METHOD_TERMS} code — `impulse-onset`, `declared-port` or `note-onset`. */
   readonly method: string;
   readonly blockFrames: number;
   /** What was fed in, in words. An onset measured through an opened gate is not the same