@openmixer/plugin-qualify 0.18.0 → 0.18.1

package/dist/qualify-sync.d.ts

@@ -1,7 +1,9 @@
 import { type HostProfile } from "./host-profiles.js";
 import { type PinEntry } from "./pins-file.js";
 import { type PinFilesRun } from "./hostd-pin-files.js";
+import { type ProbeRun } from "./probe-runner.js";
 import { type GridSpec } from "./measurement-grid.js";
+import { type AdapterPassOptions } from "./qualify-adapter-pass.js";
 import { type MemoryBound } from "./memory-bound.js";
 import { type NotMeasured } from "./qualification-record.js";
 /** The settings file a system service reads, `key value` per line. */
@@ -32,6 +34,8 @@ export interface SyncSettings {
     readonly cellsPerPluginBudget: number;
     /** The memory bound of every run; `undefined` is `off`. */
     readonly memory?: MemoryBound;
+    /** The notes an instrument with no declared capacity holds in a memory-only run. */
+    readonly memoryNotes: number;
     readonly hostdPort: number;
     readonly hostdFeedbackPort: number;
     readonly settleS: number;
@@ -57,6 +61,12 @@ export interface SyncArgs {
     readonly noWait: boolean;
     /** `--refresh-pins`: refresh the pins' files from plugin-hostd and measure nothing (the package's upgrade runs it). */
     readonly refreshPins: boolean;
+    /** `--rejudge`: the verdicts, tiers and pins derived again from the records' figures, measuring nothing. */
+    readonly rejudge: boolean;
+    /** `--memory-only`: the footprint of each recorded plugin at the Pi's cells, merged into its record. */
+    readonly memoryOnly: boolean;
+    /** `--adapter-only`: the run of each LV2 plugin under the adapter at the Pi's cells, merged into its record. */
+    readonly adapterOnly: boolean;
     readonly help: boolean;
     /** The settings given as flags, by key. */
     readonly values: ReadonlyMap<string, string>;
@@ -89,15 +99,30 @@ export interface SyncItem {
     readonly files: readonly string[];
     /** The LV2 plugin's uri. */
     readonly uri?: string;
+    /** The LV2 plugin's binary as lilv loads it, an absolute path that may lie outside `root` (a complement's). */
+    readonly binary?: string;
 }
+/** One LV2 plugin as lilv resolves it over the whole search path: the bundle its version rule takes, and its binary. */
+export interface Lv2Resolved {
+    readonly uri: string;
+    readonly bundle: string;
+    readonly binary?: string | null;
+}
+/** The bundles lilv takes over `dirs`, or why it could not say. A stand-in in tests. */
+export type Lv2Resolve = (dirs: readonly string[]) => readonly Lv2Resolved[] | {
+    readonly problem: string;
+};
+/** lilv itself, one world over the whole search path (tools/lv2_resolve.py), as every host built on it resolves (#199). */
+export declare const LILV_RESOLVE: Lv2Resolve;
 /**
  * Every item on the search paths. A `.clap` is one item; an LV2 plugin is one item, found in the first bundle on the
  * LV2 directories that declares it, as plugin-hostd finds it. A directory that cannot be read is a problem named, and
  * the others are still walked.
  */
-export declare function discoverSyncItems(settings: Pick<SyncSettings, "lv2Dirs" | "clapDirs">): {
+export declare function discoverSyncItems(settings: Pick<SyncSettings, "lv2Dirs" | "clapDirs">, lv2Resolve?: Lv2Resolve): {
     items: SyncItem[];
     problems: string[];
+    notes: string[];
 };
 /** One file of a set: its SHA-256, as plugin-hostd's `pin.h` digests it, and the stat it was taken at. */
 export interface FileDigest {
@@ -130,6 +155,13 @@ export declare const SYNC_CODE: {
     /** The probe runner wrote no document to judge. */
     readonly notMeasured: "qualify.sync.not-measured";
 };
+/**
+ * Why a plugin is unmeasured because of the machine it ran on rather than what it is (#192): an EACCES, EPERM or
+ * ENOSPC the run hit, or a measurement that could not run or wrote no document. Such a plugin is measured again by
+ * the next run although its files are unchanged; a reason of the plugin's own (probe.limit.not-implemented, no such
+ * plugin, a crash) is not. `undefined` for every other outcome.
+ */
+export declare function machineReason(p: Pick<SyncPlugin, "outcome" | "code" | "detail">): string | undefined;
 /** What the quick qualification never measures, stated in every record it writes. */
 export declare const QUICK_NOT_MEASURED: readonly NotMeasured[];
 export interface SyncPlugin {
@@ -168,6 +200,13 @@ export declare function recordedAsIs(item: SyncItem, entry: SyncEntry | undefine
     same: boolean;
     files?: FileDigest[];
 };
+/**
+ * The entry of an LV2 plugin a host now loads from another bundle than it was qualified in, when its binary is the
+ * same bytes (#199): the entry with the new bundle and the new bundle's file digests, its verdicts and records kept.
+ * `undefined` when the item is not that case: not LV2, no entry, the same bundle, a binary that cannot be read, or one
+ * whose bytes differ from the recorded binary's (then it is measured again).
+ */
+export declare function sameBinaryElsewhere(item: SyncItem, entry: SyncEntry | undefined): SyncEntry | undefined;
 export interface SyncContext {
     readonly settings: SyncSettings;
     readonly env: Readonly<Record<string, string | undefined>>;
@@ -241,6 +280,26 @@ export interface SyncSummary {
     readonly sent?: number;
     /** The pins whose files were refreshed from plugin-hostd without a measurement (plugin-qualify#239). */
     readonly refreshed?: number;
+    /** `--rejudge`: the records whose verdicts changed, the ones that stood, and the ones that owe a measurement. */
+    readonly rejudge?: {
+        readonly changed: number;
+        readonly unchanged: number;
+        readonly owing: number;
+    };
+    /** `--memory-only`: the plugins measured, those whose footprints were already merged, and those no run could read. */
+    readonly memoryOnly?: {
+        readonly measured: number;
+        readonly already: number;
+        readonly failed: number;
+    };
+    /** Every plugin the run measured was unmeasured for this one reason of the machine ({@link machineReason}): the run failed. */
+    readonly machineFailure?: string;
+    /** `--adapter-only`: the plugins run, those done already at these host versions, and those whose host could not be run. */
+    readonly adapterOnly?: {
+        readonly measured: number;
+        readonly already: number;
+        readonly failed: number;
+    };
 }
 /**
  * Why a reader that is not the sync's user (the console, #221) cannot read the descriptors: the directory or one of its
@@ -263,8 +322,20 @@ export interface SyncRunOptions {
     readonly force?: boolean;
     /** `--refresh-pins`: only refresh the pins' files from plugin-hostd and send the changed ones; measure nothing. */
     readonly refreshOnly?: boolean;
+    /** `--rejudge`: derive the verdicts again from the records' figures; measure nothing. */
+    readonly rejudge?: boolean;
+    /** `--memory-only`: take only the footprints; `force` takes those already merged again. */
+    readonly memoryOnly?: boolean;
+    /** `--adapter-only`: take only the adapter runs; `force` takes those already done again. */
+    readonly adapterOnly?: boolean;
+    /** Stand-ins for the pass's hosts, in tests. */
+    readonly adapterPass?: AdapterPassOptions;
     /** The run of `plugin-hostd --pin-files`, a stand-in in tests. */
     readonly pinFilesRun?: PinFilesRun;
+    /** The run of the probe runner in a memory-only pass, a stand-in in tests. */
+    readonly probeRun?: ProbeRun;
+    /** How LV2 plugins are resolved to the bundle a host loads: lilv itself unless a test stands in (#199). */
+    readonly lv2Resolve?: Lv2Resolve;
     /** False under `--no-wait`: a run in progress is not waited for; the holder runs once more at its end instead. */
     readonly wait?: boolean;
     readonly env?: Readonly<Record<string, string | undefined>>;

package/dist/qualify-sync.js

@@ -18,7 +18,7 @@
  */
 import { spawn, spawnSync } from "node:child_process";
 import { createHash } from "node:crypto";
-import { closeSync, existsSync, lstatSync, mkdirSync, mkdtempSync, openSync, readFileSync, readSync, readdirSync, renameSync, rmSync, statSync, symlinkSync, unlinkSync, writeFileSync } from "node:fs";
+import { closeSync, existsSync, lstatSync, mkdirSync, mkdtempSync, openSync, readFileSync, readSync, readdirSync, realpathSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { createConnection } from "node:net";
 import { homedir, tmpdir } from "node:os";
 import { basename, dirname, join, resolve, sep } from "node:path";
@@ -32,9 +32,11 @@ import { judgmentPinEntries, pinsFile } from "./pins-file.js";
 import { hostdPinFiles } from "./hostd-pin-files.js";
 import { qualifyTargets } from "./probe-runner.js";
 import { GRID_FULL, parseGridSpec } from "./measurement-grid.js";
+import { adapterPass } from "./qualify-adapter-pass.js";
+import { lv2World, rejudgeState, memoryPass } from "./qualify-rejudge.js";
 import { memoryBoundOf, parseMemoryLimit } from "./memory-bound.js";
 import { writeQualification } from "./qualification-record.js";
-import { DESCRIPTOR_DIR_STATE_SUBDIR, DESCRIPTOR_DIR_SYSTEM, QUALIFY_QUANTA, QUALIFY_RATES } from "./qualify-declarations.js";
+import { DESCRIPTOR_DIR_STATE_SUBDIR, DESCRIPTOR_DIR_SYSTEM, MEMORY_PASS_PROBE_NOTES, QUALIFY_QUANTA, QUALIFY_RATES } from "./qualify-declarations.js";
 import { toolsDir } from "./tool-paths.js";
 import { writeFileWhole } from "./whole-file.js";
 // --- the settings -----------------------------------------------------------------------------------------------------
@@ -59,6 +61,7 @@ export const SYNC_SETTINGS = [
     { key: "grid", meaning: "the cells measured: full (every rate at every block size, 16 cells), hosts (the fast option: the host's and the console tiers' rate/quantum, then 512 at every rate; also --grid-hosts), or <rate>/<quantum>,...", default: "full" },
     { key: "cells_per_plugin_budget", meaning: "measure at most the first n cells of the grid a plugin; 0 is every cell", default: "0" },
     { key: "memory_limit", meaning: "the memory bound of every run: bytes, or with K, M, G; off for none; past it a cell is probe.oom", default: "half of the RAM" },
+    { key: "memory_notes", meaning: "the notes an instrument that declares no voice capacity holds in a --memory-only run, 1 to 128 (basis probe)", default: String(MEMORY_PASS_PROBE_NOTES) },
     { key: "hostd_port", meaning: "plugin-hostd's command port the new pins are sent to; 0 sends none", default: "5555" },
     { key: "hostd_feedback_port", meaning: "plugin-hostd's feedback port, connected before the command port; 0 is the command port's next", default: "0" },
     { key: "settle_s", meaning: "wait until the plugin directories have been quiet this long before a run", default: "0" },
@@ -92,6 +95,9 @@ export function parseSyncArgs(argv) {
     let noDistributed = false;
     let noWait = false;
     let refreshPinsOnly = false;
+    let rejudge = false;
+    let memoryOnly = false;
+    let adapterOnly = false;
     let help = false;
     for (let i = 0; i < argv.length; i++) {
         const a = argv[i];
@@ -105,6 +111,12 @@ export function parseSyncArgs(argv) {
             noWait = true;
         else if (a === "--refresh-pins")
             refreshPinsOnly = true;
+        else if (a === "--rejudge")
+            rejudge = true;
+        else if (a === "--memory-only")
+            memoryOnly = true;
+        else if (a === "--adapter-only")
+            adapterOnly = true;
         else if (a === "--help")
             help = true;
         else if (a === "--grid-hosts")
@@ -121,7 +133,11 @@ export function parseSyncArgs(argv) {
         else
             return { ok: false, error: `unknown argument ${a}` };
     }
-    return { ok: true, args: { ...(config === undefined ? {} : { config }), system, force, noDistributed, noWait, refreshPins: refreshPinsOnly, help, values } };
+    if (rejudge && (memoryOnly || adapterOnly || force || refreshPinsOnly))
+        return { ok: false, error: "--rejudge measures nothing: it goes with none of --memory-only, --adapter-only, --force and --refresh-pins" };
+    if ([memoryOnly, adapterOnly, refreshPinsOnly].filter(Boolean).length > 1)
+        return { ok: false, error: "--memory-only, --adapter-only and --refresh-pins are different runs: one at a time" };
+    return { ok: true, args: { ...(config === undefined ? {} : { config }), system, force, noDistributed, noWait, refreshPins: refreshPinsOnly, rejudge, memoryOnly, adapterOnly, help, values } };
 }
 export function syncHelpText() {
     const rows = SYNC_SETTINGS.map((s) => `  ${`${flagOf(s.key)} <value>`.padEnd(36)}${s.meaning}${s.default === "" ? "" : ` (default: ${s.default})`}`);
@@ -134,6 +150,9 @@ export function syncHelpText() {
         "  --no-wait                           a run in progress is not waited for: exit 0, and the holder runs once more at its end",
         "  --no-distributed                    read no distributed record: every plugin not recorded is measured",
         "  --refresh-pins                      only bring every pin's files up to the ones plugin-hostd names, measuring nothing",
+        "  --rejudge                           derive every record's verdicts, tiers and pin again from the figures it holds; measures nothing",
+        "  --memory-only                       measure only the footprint of each recorded plugin at the Pi's cells and merge it; with --force, those already merged too",
+        "  --adapter-only                      run each LV2 plugin only under omx-clap-host's LV2 adapter at the Pi's cells, on private JACK servers, and merge it; with --force, those already done too",
         "  --grid-hosts                        the fast grid, the same as --grid hosts (7 cells with the shipped hosts)",
         "  --help                              this text",
         ...rows,
@@ -184,6 +203,9 @@ export function resolveSyncSettings(file, args, env, home = homedir(), boardMode
     if (memoryLimit !== undefined && !memoryLimit.ok)
         return { ok: false, error: `memory_limit: ${memoryLimit.error}` };
     const memory = memoryBoundOf(memoryLimit?.bytes);
+    const memoryNotes = number("memory_notes", 1);
+    if (memoryNotes === undefined || !Number.isInteger(memoryNotes) || memoryNotes > 128)
+        return { ok: false, error: "memory_notes must be a whole number of notes, 1 to 128" };
     const profileId = get("host_profile") || "omx-clap-host";
     const hostProfile = shippedHostProfile(profileId);
     if (hostProfile === undefined)
@@ -215,6 +237,7 @@ export function resolveSyncSettings(file, args, env, home = homedir(), boardMode
             grid: grid.spec,
             cellsPerPluginBudget,
             ...(memory === undefined ? {} : { memory }),
+            memoryNotes,
             hostdPort,
             hostdFeedbackPort: feedbackPort === 0 && hostdPort !== 0 ? hostdPort + 1 : feedbackPort,
             settleS,
@@ -224,6 +247,29 @@ export function resolveSyncSettings(file, args, env, home = homedir(), boardMode
         },
     };
 }
+/** lilv itself, one world over the whole search path (tools/lv2_resolve.py), as every host built on it resolves (#199). */
+export const LILV_RESOLVE = (dirs) => {
+    const r = spawnSync("python3", [join(toolsDir(), "lv2_resolve.py")], {
+        encoding: "utf8", timeout: 120_000, killSignal: "SIGKILL", maxBuffer: 64 << 20, env: { ...process.env, LV2_PATH: dirs.join(":") },
+    });
+    if (r.error !== undefined || r.status !== 0)
+        return { problem: (r.stderr ?? "").trim().split("\n").pop() || (r.error?.message ?? `exit ${String(r.status)}`) };
+    try {
+        return JSON.parse(r.stdout).plugins;
+    }
+    catch (e) {
+        return { problem: `lv2_resolve.py printed no JSON: ${e.message}` };
+    }
+};
+/** Whether `path` exists and is, through its links, the file `target` is. */
+function linksTo(path, target) {
+    try {
+        return realpathSync(path) === realpathSync(target);
+    }
+    catch {
+        return false;
+    }
+}
 const CLAP_SUFFIX = ".clap";
 /** Every `.clap` under a directory, its subdirectories included, in name order; a directory reached twice is walked once. */
 function clapFiles(dir, seen, problems) {
@@ -270,9 +316,10 @@ function clapFiles(dir, seen, problems) {
  * LV2 directories that declares it, as plugin-hostd finds it. A directory that cannot be read is a problem named, and
  * the others are still walked.
  */
-export function discoverSyncItems(settings) {
+export function discoverSyncItems(settings, lv2Resolve) {
     const items = [];
     const problems = [];
+    const notes = [];
     const seen = new Set();
     const clap = new Set();
     for (const dir of settings.clapDirs) {
@@ -284,6 +331,14 @@ export function discoverSyncItems(settings) {
             items.push({ key: `clap:${path}`, format: "clap", root: dirname(path), files: [basename(path)] });
         }
     }
+    // the bundle lilv takes for each plugin uri; without lilv, the first bundle found (and the log says so)
+    const resolved = lv2Resolve === undefined || settings.lv2Dirs.length === 0 ? undefined : lv2Resolve(settings.lv2Dirs);
+    const taken = new Map();
+    if (resolved !== undefined && "problem" in resolved)
+        notes.push(`lilv could not resolve the LV2 plugins (${resolved.problem}); each is keyed by the first bundle found`);
+    else if (resolved !== undefined)
+        for (const p of resolved)
+            taken.set(p.uri, p);
     const lv2 = new Set();
     for (const dir of settings.lv2Dirs) {
         let bundles;
@@ -304,14 +359,23 @@ export function discoverSyncItems(settings) {
                 continue;
             }
             for (const p of manifestPlugins(ttl)) {
+                const lilv = taken.get(p.uri);
+                // lilv takes another bundle for this uri: this one is not the plugin a host loads
+                if (lilv !== undefined && resolve(lilv.bundle) !== resolve(bundle))
+                    continue;
                 if (lv2.has(p.uri))
                     continue;
                 lv2.add(p.uri);
-                items.push({ key: `lv2:${p.uri}`, format: "lv2", root: bundle, files: ["manifest.ttl", ...p.files.filter((f) => f !== "manifest.ttl")], uri: p.uri });
+                const binary = lilv?.binary ?? (p.binary === undefined ? undefined : join(bundle, p.binary));
+                const files = ["manifest.ttl", ...p.files.filter((f) => f !== "manifest.ttl")];
+                // a binary named by an absolute IRI (a complement's) is tracked through the bundle's link to it, when it has one
+                if (binary !== undefined && !files.includes(basename(binary)) && linksTo(join(bundle, basename(binary)), binary))
+                    files.push(basename(binary));
+                items.push({ key: `lv2:${p.uri}`, format: "lv2", root: bundle, files, uri: p.uri, ...(binary === undefined ? {} : { binary }) });
             }
         }
     }
-    return { items, problems };
+    return { items, problems, notes };
 }
 /** The SHA-256 of a file's bytes, read in pieces over one descriptor. */
 export function fileSha256(path) {
@@ -365,6 +429,20 @@ export const SYNC_CODE = {
     /** The probe runner wrote no document to judge. */
     notMeasured: "qualify.sync.not-measured",
 };
+/**
+ * Why a plugin is unmeasured because of the machine it ran on rather than what it is (#192): an EACCES, EPERM or
+ * ENOSPC the run hit, or a measurement that could not run or wrote no document. Such a plugin is measured again by
+ * the next run although its files are unchanged; a reason of the plugin's own (probe.limit.not-implemented, no such
+ * plugin, a crash) is not. `undefined` for every other outcome.
+ */
+export function machineReason(p) {
+    if (p.outcome !== "unmeasured" || p.code !== SYNC_CODE.notMeasured)
+        return undefined;
+    const errno = /\b(EACCES|EPERM|ENOSPC)\b/.exec(p.detail ?? "")?.[1];
+    if (errno !== undefined)
+        return errno;
+    return /wrote no document|cannot run the probe runner/.test(p.detail ?? "") ? "the measurement wrote no document" : undefined;
+}
 /** What the quick qualification never measures, stated in every record it writes. */
 export const QUICK_NOT_MEASURED = [{ dimension: "stability", code: HOSTING_CODE.stabilityUnsoaked }];
 const EMPTY_STATE = { schema: SYNC_STATE_SCHEMA, entries: {} };
@@ -402,6 +480,32 @@ export function recordedAsIs(item, entry) {
     const same = now.length === entry.files.length && now.every((f) => entry.files.some((e) => e.path === f.path && e.sha256 === f.sha256));
     return { same, files: now };
 }
+/**
+ * The entry of an LV2 plugin a host now loads from another bundle than it was qualified in, when its binary is the
+ * same bytes (#199): the entry with the new bundle and the new bundle's file digests, its verdicts and records kept.
+ * `undefined` when the item is not that case: not LV2, no entry, the same bundle, a binary that cannot be read, or one
+ * whose bytes differ from the recorded binary's (then it is measured again).
+ */
+export function sameBinaryElsewhere(item, entry) {
+    if (item.format !== "lv2" || entry === undefined || item.binary === undefined || resolve(entry.root) === resolve(item.root))
+        return undefined;
+    const was = entry.files.find((f) => basename(f.path) === basename(item.binary));
+    if (was === undefined)
+        return undefined;
+    let now;
+    try {
+        now = fileSha256(item.binary);
+    }
+    catch {
+        return undefined;
+    }
+    if (now !== was.sha256)
+        return undefined;
+    const files = digestFiles(item.root, item.files);
+    if (files === undefined)
+        return undefined;
+    return { ...entry, root: item.root, files };
+}
 /**
  * The pin of a judged run with the files plugin-hostd collects for its plugin (plugin-qualify#228): the probe's list is
  * the probe's view, and an add checks the daemon's, so a pin holds the daemon's. No pin when plugin-hostd cannot name
@@ -595,15 +699,10 @@ function qualifyClap(ctx, item) {
 }
 /** An LV2 plugin, measured in a world of its own bundle only, as plugin-hostd runs a pinned LV2 plugin. */
 function qualifyLv2(ctx, item) {
-    const world = mkdtempSync(join(tmpdir(), "plugin-qualify-sync-world-"));
-    try {
-        symlinkSync(item.root, join(world, basename(item.root)));
+    return lv2World(item.root, (world) => {
         const pass = runPass(ctx, { format: "lv2", uri: item.uri, bundle: item.root }, { ...ctx.env, LV2_PATH: world });
         return [...pass.failures.map((f) => ({ uri: item.uri, outcome: "unmeasured", code: SYNC_CODE.notMeasured, detail: f.problem })), ...judgedPlugins(ctx, pass.runs)];
-    }
-    finally {
-        rmSync(world, { recursive: true, force: true });
-    }
+    });
 }
 /** One item qualified, whatever happens to it: an error of the sync's own while measuring it is its outcome, not the run's end. */
 export function qualifyItem(ctx, item, files) {
@@ -913,7 +1012,7 @@ export function descriptorAccessProblems(dir) {
     return problems;
 }
 export function summaryLine(s) {
-    return `qualified ${String(s.qualified)}, skipped ${String(s.skipped)}, refused ${String(s.refused)}, crashed ${String(s.crashed)}, hung ${String(s.hung)}, unmeasured ${String(s.unmeasured)}, distributed ${String(s.distributed)}${s.refreshed ? `, pins refreshed ${String(s.refreshed)}` : ""}, ${s.seconds.toFixed(1)} s`;
+    return `qualified ${String(s.qualified)}, skipped ${String(s.skipped)}, refused ${String(s.refused)}, crashed ${String(s.crashed)}, hung ${String(s.hung)}, unmeasured ${String(s.unmeasured)}, distributed ${String(s.distributed)}${s.refreshed ? `, pins refreshed ${String(s.refreshed)}` : ""}${s.rejudge === undefined ? "" : `, rejudged ${String(s.rejudge.changed)}, unchanged ${String(s.rejudge.unchanged)}, owing ${String(s.rejudge.owing)}`}${s.memoryOnly === undefined ? "" : `, memory measured ${String(s.memoryOnly.measured)}, already ${String(s.memoryOnly.already)}, failed ${String(s.memoryOnly.failed)}, leaks not measured`}${s.adapterOnly === undefined ? "" : `, adapter run ${String(s.adapterOnly.measured)}, already ${String(s.adapterOnly.already)}, failed ${String(s.adapterOnly.failed)}`}, ${s.seconds.toFixed(1)} s`;
 }
 /** The exit status `flock -n` returns when the lock is held (-E), told apart from a failure of flock itself. */
 const LOCK_HELD = 99;
@@ -995,6 +1094,9 @@ function addSummaries(a, b) {
         seconds: a.seconds + b.seconds,
         ...(sent === 0 ? {} : { sent }),
         ...(refreshed === 0 ? {} : { refreshed }),
+        ...(b.rejudge === undefined ? (a.rejudge === undefined ? {} : { rejudge: a.rejudge }) : { rejudge: b.rejudge }),
+        ...(b.memoryOnly === undefined ? (a.memoryOnly === undefined ? {} : { memoryOnly: a.memoryOnly }) : { memoryOnly: b.memoryOnly }),
+        ...(b.adapterOnly === undefined ? (a.adapterOnly === undefined ? {} : { adapterOnly: a.adapterOnly }) : { adapterOnly: b.adapterOnly }),
     };
 }
 /** Whether this run's scan covers an entry: its root lies under one of the run's directories of its own format. */
@@ -1013,7 +1115,7 @@ function scannedBy(settings, entry) {
 async function runLocked(settings, options) {
     const log = options.log ?? (() => { });
     const env = options.env ?? process.env;
-    log(options.refreshOnly === true ? "pin refresh begins" : "sync run begins");
+    log(options.rejudge === true ? "re-judge begins: nothing is measured" : options.memoryOnly === true ? "memory-only pass begins" : options.adapterOnly === true ? "adapter-only pass begins" : options.refreshOnly === true ? "pin refresh begins" : "sync run begins");
     {
         const started = Date.now();
         const dirs = [...settings.clapDirs, ...settings.lv2Dirs];
@@ -1026,6 +1128,24 @@ async function runLocked(settings, options) {
         }
         if (options.refreshOnly === true)
             return sendRefreshed(settings, fresh.state, fresh.refreshed.length, started, log);
+        if (options.rejudge === true) {
+            const r = rejudgeState(ctx, fresh.state);
+            if (JSON.stringify(r.state) !== JSON.stringify(fresh.state))
+                writeFileWhole(settings.stateFile, `${JSON.stringify(r.state, null, 1)}\n`);
+            const summary = await sendRefreshed(settings, r.state, fresh.refreshed.length, started, log);
+            return { ...summary, rejudge: { changed: r.changed, unchanged: r.unchanged, owing: r.owing.length } };
+        }
+        if (options.adapterOnly === true) {
+            const r = adapterPass(ctx, fresh.state, { ...options.adapterPass, force: options.force === true });
+            log(`adapter runs under ${Object.entries(r.versions).map(([k, v]) => `${k} ${v}`).join(", ")}`);
+            const summary = await sendRefreshed(settings, fresh.state, fresh.refreshed.length, started, log);
+            return { ...summary, adapterOnly: { measured: r.measured, already: r.already, failed: r.failed } };
+        }
+        if (options.memoryOnly === true) {
+            const r = memoryPass(ctx, fresh.state, { force: options.force === true, ...(options.probeRun === undefined ? {} : { run: options.probeRun }) });
+            const summary = await sendRefreshed(settings, fresh.state, fresh.refreshed.length, started, log);
+            return { ...summary, memoryOnly: { measured: r.measured, already: r.already, failed: r.failed } };
+        }
         await waitQuiet(dirs, settings.settleS, log);
         const count = { qualified: 0, skipped: 0, refused: 0, crashed: 0, hung: 0, unmeasured: 0, distributed: 0 };
         const layer = distributedLayerOf(settings, options.force === true, log);
@@ -1040,12 +1160,18 @@ async function runLocked(settings, options) {
         const stateBefore = state;
         let unreadable = false;
         const lv2Pinned = [];
+        // the plugins measured this run, and how many of them the machine left unmeasured, by reason (#192)
+        let measuredHere = 0;
+        const byMachine = new Map();
         // a change made while a pass ran is caught by one more pass, a few at most
         for (let pass = 0; pass < 3; pass++) {
             const signature = directoriesSignature(dirs);
-            const { items, problems } = discoverSyncItems(settings);
+            const { items, problems, notes } = discoverSyncItems(settings, options.lv2Resolve ?? LILV_RESOLVE);
             for (const p of problems)
                 log(p);
+            if (pass === 0)
+                for (const n of notes)
+                    log(n);
             unreadable = problems.length > 0;
             const found = new Set(items.map((i) => i.key));
             const entries = {};
@@ -1063,11 +1189,29 @@ async function runLocked(settings, options) {
             }
             for (const item of items) {
                 const recorded = recordedAsIs(item, entries[item.key]);
-                if (recorded.same && options.force !== true) {
+                const retry = recorded.same ? entries[item.key].plugins.map(machineReason).find((r) => r !== undefined) : undefined;
+                if (recorded.same && options.force !== true && retry === undefined) {
                     if (pass === 0)
                         count.skipped += entries[item.key].plugins.length;
                     continue;
                 }
+                // an LV2 plugin a host now loads from another bundle with the same binary (a complement that restates its TTL,
+                // #199): the record stands, keyed by its uri and its binary; only the bundle, its files and the pins' files move
+                const moved = options.force === true ? undefined : sameBinaryElsewhere(item, entries[item.key]);
+                if (moved !== undefined) {
+                    entries[item.key] = { ...moved, plugins: moved.plugins.map((p) => ({ ...p, ...(p.pin === undefined ? {} : { pin: withHostdFiles(ctx, p.pin) }) })) };
+                    if (item.format === "lv2")
+                        lv2Pinned.push(...entries[item.key].plugins.filter((p) => p.pin !== undefined).map((p) => p.uri));
+                    if (pass === 0)
+                        count.skipped += moved.plugins.length;
+                    log(`${item.key}: loaded from ${item.root} now, with the binary it was qualified with; its record stands and its pin's files follow the bundle`);
+                    state = { schema: SYNC_STATE_SCHEMA, entries };
+                    writeFileWhole(settings.stateFile, `${JSON.stringify(state, null, 1)}\n`);
+                    writeFileWhole(settings.pinFile, syncPinsText(state));
+                    continue;
+                }
+                if (recorded.same && retry !== undefined)
+                    log(`${item.key}: unmeasured last run by the machine (${retry}); measured again`);
                 const files = recorded.files ?? digestFiles(item.root, item.files);
                 if (files === undefined) {
                     log(`${item.key}: a file of it cannot be read; skipped this run`);
@@ -1092,6 +1236,13 @@ async function runLocked(settings, options) {
                     lv2Pinned.push(...entry.plugins.filter((p) => p.pin !== undefined).map((p) => p.uri));
                 for (const p of entry.plugins) {
                     count[p.outcome]++;
+                    measuredHere++;
+                    // a reason of the machine is said once: the plugins after the first are counted, not listed
+                    const why = machineReason(p);
+                    if (why !== undefined)
+                        byMachine.set(why, (byMachine.get(why) ?? 0) + 1);
+                    if (why !== undefined && byMachine.get(why) > 1)
+                        continue;
                     log(`${p.uri}: ${p.outcome}${p.code === undefined ? "" : ` (${p.code})`}${p.detail === undefined ? "" : `: ${p.detail}`}`);
                 }
                 state = { schema: SYNC_STATE_SCHEMA, entries };
@@ -1133,8 +1284,16 @@ async function runLocked(settings, options) {
             if (replies[i] !== "resp 0")
                 log(`plugin-hostd answered ${replies[i]} to ${changed[i].split(" ")[1]}`);
         const taken = replies.filter((r) => r === "resp 0").length;
+        for (const [why, n] of byMachine)
+            if (n > 1)
+                log(`${String(n)} plugins unmeasured by the machine (${why}); the first is listed above`);
+        const [only] = byMachine.size === 1 ? [...byMachine] : [];
+        const machineFailure = only !== undefined && only[1] === measuredHere ? only[0] : undefined;
+        if (machineFailure !== undefined)
+            log(`every plugin this run measured was left unmeasured by the machine (${machineFailure}): the run failed`);
         return {
             ...count,
+            ...(machineFailure === undefined ? {} : { machineFailure }),
             seconds: (Date.now() - started) / 1000,
             ...(taken === 0 ? {} : { sent: taken }),
             ...(fresh.refreshed.length === 0 ? {} : { refreshed: fresh.refreshed.length }),