@openmixer/plugin-qualify 0.7.0 → 0.9.0

package/src/tool-paths.ts

@@ -50,11 +50,28 @@ export function lv2MeasureNativePath(): string {
   return join(nativeBuildDir(), LV2_MEASURE_TOOL_NAME);
 }
 
-/** Where a native tool is looked for when no setting names it, in order: the installed directories, then the own build. */
+/**
+ * Where the native tools are looked for when no setting names them, in order: the package's own build,
+ * then the installed directories. An installed package has no `native/build/`, so its own build first
+ * changes nothing there, and in a checkout `make -C native` is never shadowed by an older install.
+ */
+export function nativeToolDirs(): string[] {
+  return [nativeBuildDir(), ...NATIVE_TOOL_DIRS];
+}
+
+/** Where one native tool is looked for when no setting names it, in `nativeToolDirs` order. */
 export function nativeToolCandidates(name: string): string[] {
-  return [...NATIVE_TOOL_DIRS, nativeBuildDir()].map((dir) => join(dir, name));
+  return nativeToolDirs().map((dir) => join(dir, name));
 }
 
+function settingOf(name: string): string {
+  const setting = NATIVE_TOOLS.find((t) => t.name === name)?.env;
+  if (setting === undefined) throw new Error(`${name} is not one of NATIVE_TOOLS`);
+  return setting;
+}
+
+const isSet = (v: string | undefined): v is string => v !== undefined && v !== "";
+
 /**
  * One of `NATIVE_TOOLS`: its setting when set (and only that), else the first candidate that exists.
  * `path` is absent when none does; `looked` is every place tried, for the refusal to name.
@@ -64,10 +81,56 @@ export function locateNativeTool(
   env: Readonly<Record<string, string | undefined>>,
   exists: (path: string) => boolean,
 ): { readonly path?: string; readonly looked: readonly string[]; readonly setting: string } {
-  const setting = NATIVE_TOOLS.find((t) => t.name === name)?.env;
-  if (setting === undefined) throw new Error(`${name} is not one of NATIVE_TOOLS`);
+  const setting = settingOf(name);
   const v = env[setting];
-  const looked = v === undefined || v === "" ? nativeToolCandidates(name) : [v];
+  const looked = isSet(v) ? [v] : nativeToolCandidates(name);
   const path = looked.find((p) => exists(p));
   return { ...(path === undefined ? {} : { path }), looked, setting };
 }
+
+/** One tool of a set `locateNativeTools` located, as `locateNativeTool` reports it. */
+export interface LocatedNativeTool {
+  readonly name: string;
+  readonly path?: string;
+  readonly looked: readonly string[];
+  readonly setting: string;
+}
+
+/**
+ * Tools that run together and share an ABI (a prober or the measurer, and the interposer through
+ * `rt-interpose.h`): each set one is its setting; the rest come from ONE directory, the first of
+ * `nativeToolDirs` holding any of them. When that directory lacks some of them, `halfPopulated`
+ * names it and what it lacks, and the run is refused: pairing a tool from one place with its
+ * interposer from another would let a version skew corrupt the verdict without an error.
+ */
+export function locateNativeTools(
+  names: readonly string[],
+  env: Readonly<Record<string, string | undefined>>,
+  exists: (path: string) => boolean,
+): {
+  readonly tools: readonly LocatedNativeTool[];
+  readonly halfPopulated?: { readonly dir: string; readonly holds: readonly string[]; readonly lacks: readonly string[] };
+} {
+  const unset = names.filter((name) => !isSet(env[settingOf(name)]));
+  const dir = nativeToolDirs().find((d) => unset.some((name) => exists(join(d, name))));
+  const tools = names.map((name): LocatedNativeTool => {
+    const setting = settingOf(name);
+    const v = env[setting];
+    if (isSet(v)) return { name, setting, looked: [v], ...(exists(v) ? { path: v } : {}) };
+    const path = dir === undefined ? undefined : join(dir, name);
+    return { name, setting, looked: nativeToolCandidates(name), ...(path !== undefined && exists(path) ? { path } : {}) };
+  });
+  if (dir === undefined) return { tools };
+  const lacks = unset.filter((name) => !exists(join(dir, name)));
+  if (lacks.length === 0) return { tools };
+  return { tools, halfPopulated: { dir, holds: unset.filter((name) => !lacks.includes(name)), lacks } };
+}
+
+/** The refusal for a half-populated directory: what it holds, what it lacks, and the settings that would decide. */
+export function halfPopulatedRefusal(half: { readonly dir: string; readonly holds: readonly string[]; readonly lacks: readonly string[] }): string {
+  const settings = [...half.holds, ...half.lacks].map(settingOf).join(" and ");
+  return (
+    `${half.dir} holds ${half.holds.join(", ")} but not ${half.lacks.join(", ")}: they share one ABI and are ` +
+    `taken from one place, so install or build them together, or set ${settings}`
+  );
+}

package/tools/lv2-measure.mjs

@@ -8,8 +8,8 @@
  * Standalone by construction: it needs `python3` with the `lilv` bindings, the two probers
  * next to this file (`scan.py`, `benchmark.py`), and an LV2 world to look at; the hosting
  * dimensions need the package's native measurer and interposer (`lv2_measure`,
- * `rt_interpose.so`), each its setting (`OMX_LV2_MEASURE`, `OMX_RT_INTERPOSE`), else where the
- * package installs it, else `native/build` (`make -C native`). It does not
+ * `rt_interpose.so`), each its setting (`OMX_LV2_MEASURE`, `OMX_RT_INTERPOSE`), else
+ * `native/build` (`make -C native`), else where the package installs it. It does not
  * need the OpenMixer engine, its server, PipeWire, JACK, an audio interface, or root. Nothing
  * it writes is openmixer-shaped — the output is the interchange format described in
  * `src/measurement/format.ts`, which any LV2 host can read.
@@ -60,7 +60,7 @@ import {
   urisFromScan,
 } from "../dist/measurement/index.js";
 import { LV2_HOSTING_TIMEOUT_S, LV2_MEASURE_TOOL_NAME, RT_INTERPOSE_NAME } from "../dist/qualify-declarations.js";
-import { locateNativeTool } from "../dist/tool-paths.js";
+import { halfPopulatedRefusal, locateNativeTools } from "../dist/tool-paths.js";
 
 const HERE = dirname(fileURLToPath(import.meta.url));
 
@@ -85,6 +85,22 @@ const HELP = `${TOOL_NAME} ${TOOL_VERSION} — measure LV2 plugin latency and CP
   --dry-run               Print the plan and probe nothing.
   --progress-json         Emit machine-readable progress on stderr, one '@progress {...}' per line.
   --help                  This text.
+
+The hosting pass's host features are omx-clap-core's LV2 feature provider; each of its options is
+a flag, passed to every run of lv2_measure and named in each plugin's record (featureOptions):
+
+  --features LIST         Kinds offered: map,unmap,options,bounded,worker,default-state,log
+                          (default: all but default-state; empty: none).
+  --strict                Refuse a plugin requiring a feature not offered, naming it (refusedFeature).
+  --no-strict             Hand it to its own instantiate without it (default).
+  --block-declares LIST   Buf-size declarations when bounded is offered: bounded,fixed,pow2
+                          (default: bounded; empty: none).
+  --block-min N           bufsz:minBlockLength (default: 1; 0: the run's block).
+  --block-max N           bufsz:maxBlockLength (default: 0, the run's block).
+  --block-nominal N       bufsz:nominalBlockLength (default: 0, the maximum).
+  --log MODE              log:log lines: silent, route (to stderr) or capture (into the record)
+                          (default: silent).
+  --log-capture-bytes N   The capture buffer, its NUL included (default: 4096).
 `;
 
 function fail(message, code = 2) {
@@ -96,16 +112,20 @@ function readJson(path) {
   return JSON.parse(readFileSync(path, "utf8"));
 }
 
-/** The native measurer and its interposer, located; absent, the run is refused naming where it looked. */
+/**
+ * The native measurer and its interposer, located together (`locateNativeTools`): absent, or half there
+ * in the one place they come from, the run is refused naming where it looked.
+ */
 function hostingTools() {
-  const at = (name) => {
-    const found = locateNativeTool(name, process.env, existsSync);
+  const { tools, halfPopulated } = locateNativeTools([LV2_MEASURE_TOOL_NAME, RT_INTERPOSE_NAME], process.env, existsSync);
+  if (halfPopulated !== undefined) fail(`no measurer and interposer pair: ${halfPopulatedRefusal(halfPopulated)}`);
+  const [tool, interposer] = tools.map((found) => {
     if (found.path === undefined) {
-      fail(`no ${name} at ${found.looked.join(", ")}: install the plugin-qualify package, build it with make -C native, or set ${found.setting}`);
+      fail(`no ${found.name} at ${found.looked.join(", ")}: install the plugin-qualify package, build it with make -C native, or set ${found.setting}`);
     }
     return found.path;
-  };
-  return { tool: at(LV2_MEASURE_TOOL_NAME), interposer: at(RT_INTERPOSE_NAME) };
+  });
+  return { tool, interposer };
 }
 
 /** The hosting pass: the measurer once per plugin, each in its own process, its lines written as JSONL. */