@openmixer/plugin-qualify 0.16.1 → 0.17.0

package/README.md

@@ -69,6 +69,81 @@ A named LV2 plugin is measured the same way as a CLAP one: through the probe run
 output it writes (`plugin-qualify judge` below). Exit code: `0` every plugin qualified, `1` some did not, `2`
 something could not be measured.
 
+## The measurement grid
+
+A plugin is measured in cells, each one sample rate and one quantum (block size in frames). The verdict a host
+gets reads the cell of that host's rate and quantum, so the grid has to hold it.
+
+```
+plugin-qualify --all --out ./q                          # the hosts' grid (the default, also --grid-hosts)
+plugin-qualify --all --grid full --out ./q              # every --rates rate at every --quanta quantum
+plugin-qualify --grid 48000/128,96000/1024 urn:my:fx    # exactly these cells
+```
+
+- `--grid hosts` (the default; `--grid-hosts` says the same): the rate and quantum of every host the run judges
+  (each `--host-profile`, and the console's two tiers, `openmixer-console` and the format's isolated host), then
+  quantum 512 at every `--rates` rate, so that a record stays comparable with the ones written before the grid.
+  With the four shipped hosts that is seven cells: 96000/1024 (`openmixer-console`), 48000/256 (`jalv`),
+  48000/128 (`mod-host`, `omx-clap-host`), and 512 at 44100, 48000, 96000 and 192000.
+- `--grid full`: every `--rates` rate at every `--quanta` quantum, 16 cells with the defaults
+  (44100, 48000, 96000, 192000 by 128, 256, 512, 1024).
+- `--grid <rate>/<quantum>,...`: exactly the cells named.
+
+The cells are taken in that order: the hosts' own cells first, in the order the hosts are named, then the
+512 cells, then the rest by rate and quantum. `--cells-per-plugin-budget N` keeps the first N, so a first pass
+over a large machine can measure the hosts' cells alone (`--cells-per-plugin-budget 3` with the four shipped hosts).
+`--blocks N` shortens the CLAP sweep of each cell from 512 blocks to N; the LV2 pass has a fixed shape (30
+lifecycles and 3 swept runs per cell) and is not shortened by it.
+
+An LV2 plugin is measured on the same grid as a CLAP one. plugin-hostd's runner measures an LV2 plugin at one
+rate per run (the highest it is given), which is why records written before the grid hold LV2 figures at 192000
+only; plugin-qualify now runs it once per cell. A CLAP plugin is run once per quantum, at every rate of the grid
+at that quantum. The runs of one plugin and one offer make one probe output: the grid points of every run, the
+steps of every run, and the run's outcome. The record and its byte copy hold that document.
+
+A run that ended badly leaves a grid point at each of its cells with the run's outcome in place of figures, so a
+cell is never silently absent. The cost a host is judged by is read at its cell: a measured cell is compared with
+the host's budget; a cell whose run failed reads `unknown` with that run's outcome (`probe.oom`, say); only a
+cell the grid does not hold reads `hosting.cost.unmeasured-at-rate-and-quantum`.
+
+### The memory bound
+
+A sampler loading its library can take all the memory of a small machine, and the kernel then kills it, or
+something else. Every run is bounded: `--memory-limit <bytes>` (`512M`, `2G`, or `off`), by default half of
+the machine's RAM. The bound is the runner's data limit (`--data-bytes`, `RLIMIT_DATA` on the measuring child:
+its heap and private writable mappings), and the interposer the child runs under turns an allocation refused
+under that limit into an immediate exit with status 121. A run that ends that way, or by a `SIGKILL` the
+runner did not send (the kernel's out-of-memory killer), is recorded as `probe.oom`: its cells carry the
+outcome and `memoryLimit { bytes, mechanism }`, the plugin's record is still written, and the other cells are
+judged as usual. A plugin whose every run ended `probe.oom` is `unknown` under every host, deciding `probe.oom`.
+A host whose own cell ended `probe.oom` is `unknown` there as well (`memory`, `probe.oom`): the plugin did not
+run within the bound at that host's rate and quantum.
+
+### How long a run takes
+
+Times from one deep run on a Raspberry Pi 5 (4 cores, 4 GB), 1823 records (494 CLAP, two offers of each of 247,
+and 1329 LV2), six hours in all with the grid of before (CLAP at four rates in one run at quantum 512, LV2 at
+192000/512 alone):
+
+| | runs | mean a run | total |
+| --- | --- | --- | --- |
+| CLAP, one run per offer (4 cells) | 494 | 2.8 s | 0.38 h |
+| LV2, one run (1 cell) | 1329 | 10.5 s | 3.86 h |
+| host admissions (jalv, mod-host) and the scan | | | about 1.8 h |
+
+A CLAP plugin takes one run per quantum of the grid, an LV2 plugin one run per cell; the admissions do not
+grow with the grid. On that machine, then, about:
+
+| grid | CLAP runs a plugin | LV2 runs a plugin | expected |
+| --- | --- | --- | --- |
+| hosts (7 cells) | 4 | 7 | 1.5 h + 27 h + 1.8 h, about 30 h |
+| full (16 cells) | 4 | 16 | 1.5 h + 62 h + 1.8 h, about 65 h |
+| hosts, `--cells-per-plugin-budget 3` | 3 | 3 | 1.1 h + 11.6 h + 1.8 h, about 15 h |
+
+These are ceilings: the LV2 time a run was taken at 192000, the dearest rate. `--blocks 128` takes a quarter of
+the CLAP sweep a cell. A first pass with `--cells-per-plugin-budget 3`, then `--grid full` over the plugins worth
+it, keeps a small machine's night bounded.
+
 ## CLAP plugins: the RT-safety verdict
 
 A `.clap` file, or a directory holding one, is scanned by `omx-clap-scan` (from omx-clap-core; set
@@ -95,7 +170,7 @@ are measured by `tools/lv2-measure.mjs` (below); this entry point does not drive
 system lv2 directories) rather than qualify only the CLAP side. A directory on the CLAP path that cannot
 be read (permissions, a symlink loop) also refuses with exit 2, naming it.
 
-The prober runs each plugin headless at every `--rates` rate, under an interposer that counts the
+The prober runs each plugin headless at every cell of the grid (see "The measurement grid"), under an interposer that counts the
 allocations, locks and syscalls its `process()` makes while every parameter is swept, and prints
 the file's SHA-256 beside what it measured. The verdict is the real-time-safety one: **suitable**
 only on a clean count, **unsuitable** on any allocation, lock, syscall, main-thread host call from
@@ -159,6 +234,13 @@ stays silent, an instrument with no count to hold) is left out of the grid point
 `measurements.unmeasured` with its hosting code (`hosting.latency.unmeasured`,
 `hosting.cost.unmeasured-at-rate-and-quantum`).
 
+Every cell of a record carries `latency`: the two figures when the run took them, else
+`{ unmeasuredReason, code }`, the contract's word for why and the hosting code a reader classifies by. A latency
+step that did not end well gives the child's reason (`silent-output`, say); a cell whose run failed, its outcome's
+word (`probe-crashed`, or `probe-error` for `probe.oom`); a run that took no latency at all (a runner or a child
+older than the latency arm), `not-attempted`. The declared figure alone, for a plugin whose response could not be
+measured, is not in the probe output today: plugin-hostd's runner writes a cell's latency only with both figures.
+
 
 The prober also scans: `OMX_CLAP_SCAN=native/build/clap-qualify` makes it the scanner, and its scan
 keeps what a console needs to draw a third-party plugin's controls: an enum parameter's labels (as
@@ -201,7 +283,8 @@ history outside its grammar is not read and is named on stderr; a history of a v
 `tools/lv2-measure.mjs` measures the hosting dimensions (`stability`, `rtSafety`, `features`) through
 the LV2 measurer the package installs, `lv2_measure`: each plugin is loaded through lilv in its own
 process, instantiated and destroyed 30 times, and run under the interposer while every control is
-swept, at the highest `--rates` rate:
+swept. `tools/lv2-measure.mjs` measures at the highest `--rates` rate; `plugin-qualify` runs the measurer
+once per cell of its grid (see "The measurement grid"):
 
 ```
 node tools/lv2-measure.mjs --rates 48000 --dimensions stability,rtSafety,features \
@@ -418,16 +501,16 @@ The package ships it as a service that runs two minutes after boot and whenever
 changes, once the directory has been quiet for a minute. A run finds every `.clap` under the CLAP
 directories and every plugin of every bundle under the LV2 ones, and hashes each one's files as
 plugin-hostd does for a pin. A plugin whose files hash as recorded is skipped. A new or changed one gets the
-quick qualification through the probe runner: its pin, the RT-safety sweep, cost and latency, its
+quick qualification through the probe runner, on the grid `grid` names (see "The measurement grid"): its pin, the RT-safety sweep, cost and latency, its
 qualification record and its descriptor. The soak is not part of it, and every record it writes says so in
 `notMeasured` (`hosting.stability.unsoaked`).
 
-Each plugin has `budget_s` seconds. One that crashes or hangs is recorded as `crashed` or `hung`, one that
+Each run of the runner (one cell of an LV2 plugin, one quantum of a CLAP one) has `budget_s` seconds, under `memory_limit`. One that crashes or hangs is recorded as `crashed` or `hung`, one that
 fails the sweep is pinned `verdict=refused`, and the run goes on to the next. The pin file and the state are
 written whole after every plugin, so a run cut short keeps what it finished. The last line counts the run:
 
 ```
-qualified 2, skipped 0, refused 0, crashed 1, hung 1, unmeasured 0, 4.6 s
+qualified 2, skipped 0, refused 0, crashed 1, hung 1, unmeasured 0, distributed 0, 4.6 s
 ```
 
 A plugin that is no longer found, or whose bytes changed, leaves nothing behind: its pin, its qualification
@@ -452,17 +535,81 @@ The settings are `/etc/omx/qualify.conf`, one `key value` per line, and each is
 | `state_file` | `/var/lib/omx/qualify-sync.json` |
 | `budget_s` | `60` |
 | `host_profile` | `omx-clap-host` |
+| `grid` | `hosts`: the cells of `host_profile` and of the console's two tiers, then 512 at every rate (`full`, or `<rate>/<quantum>,...`) |
+| `cells_per_plugin_budget` | `0`, every cell of the grid |
+| `memory_limit` | half of the machine's RAM (`off` for none) |
 | `hostd_port`, `hostd_feedback_port` | `5555`, the next port |
+| `host_class` | the board's own, from the device tree (`rpi5`); none elsewhere |
+| `distributed_dir` | `/usr/share/omx/qualification` |
 
 Those are the service's (`--system`); run by a user, the files go under `$XDG_STATE_HOME/omx`. An LV2
 directory added here belongs in plugin-hostd's `lv2_path` too, or the daemon cannot find the bundle it
-pinned. `--force` qualifies everything again.
+pinned. `--force` qualifies everything again, and `--no-distributed` reads no distributed record.
 
 The path unit names the standard folders (`/usr/lib/lv2`, `/usr/lib64/lv2`, `/usr/local/lib/lv2`,
 `/usr/lib/clap`, `/usr/lib64/clap`). The folders the settings file adds (`lv2_path`, `lv2_extra`, `clap_path`,
 `clap_extra`) are written into a drop-in of the unit by a systemd generator at boot and at every
 `systemctl daemon-reload`, so the file is the one place a machine's extra folders are written.
 
+### Distributed records
+
+A device that ships with a known plugin set need not measure it again at first start. The qualification records
+another device of the same machine class wrote for that set are installed read-only, and the sync takes from them
+every plugin whose files are the bytes that were measured:
+
+```
+/usr/share/omx/qualification/<host class>/<set>/          # system (--system)
+$XDG_DATA_HOME/omx/qualification/<host class>/<set>/      # a user run, then each $XDG_DATA_DIRS/omx/qualification
+```
+
+Each `<set>` directory holds the records (`*.qualification.json`, each with its probe output `*.probe.json`) and a
+`provenance.json` that says where they come from: the set, the host class, the image, the package versions of the
+measuring device, the date and the package that installed them. The host class is a directory name: `host_class`
+in the settings, or, when it is unset, the board's own name read from the device tree (`rpi5` on a Raspberry Pi 5,
+`rpi4` on a Raspberry Pi 4). Where neither gives one, the layer is not read and the run says so.
+
+Before a plugin is measured, the sync looks for a distributed record of it: a CLAP record whose binary is the same
+`.clap` path, or an LV2 record of the same plugin uri. The name only finds the record; a record applies when, and
+only when:
+
+- every file of its `binary.files` is installed at that path relative to the plugin's root, with that SHA-256,
+  computed on the device;
+- its schema is the one this version writes and its probe output is one this version's reader accepts, the copy
+  intact (its SHA-256 the one the record names): the same acceptance the sync gives a record of its own, which it
+  never measures again for a newer tool;
+- it holds a verdict for the sync's `host_profile`, and that verdict ended `qualified`, `refused`, `crashed` or
+  `hung`. One that could not be measured at the source (`unmeasured`) is measured here.
+
+A plugin whose distributed records apply is not measured: the records are copied into `qualification_dir` with the
+set's `provenance` object added, its pin is taken from the probe output the record judged, its descriptor is
+written, and the run says
+
+```
+distributed: http://distrho.sf.net/plugins/3BandEQ: applied (zynthian-vangelis)
+```
+
+A plugin with a distributed record whose files differ is measured as before, and the run says
+`distributed: <uri>: binary differs`; one with no distributed record is measured without a word. The summary counts
+the plugins taken from the layer, `distributed N`, apart from the ones measured and skipped. A later run treats an
+applied plugin like one it measured: skipped while its files are unchanged, measured when they change. `--force`
+measures everything and reads no distributed record; `--no-distributed` keeps the layer out of a run.
+
+The package that installs a set is built from a device's `qualification_dir` by `plugin-qualify-records-package`:
+
+```
+plugin-qualify-records-package /var/lib/omx/qualification --host-class rpi5 --set zynthian-vangelis \
+  --provenance provenance.json --out .
+```
+
+It writes `omx-qualification-<host class>-<set>_<version>_all.deb`, the version the build date
+(`2026.10.29`) unless `--version` names one. The package installs the records under
+`/usr/share/omx/qualification/<host class>/<set>/` with `provenance.json`, depends on the plugin-qualify that reads
+the layer, and is `Architecture: all`. `--provenance` names a JSON file (or holds the JSON itself) with what the tool
+cannot know: the image, the package versions and the source revisions of the device. The tool adds the set, the host
+class, the package and the date. A record whose probe output is missing or does not match its SHA-256 is left out
+and named; a record of a plugin that could not be measured (`*.unmeasured.json`) is left out, since it never
+applies. The tool builds the Debian package only; an RPM of a set is not built yet.
+
 ### The container image
 
 ```

package/bin/plugin-qualify-records-package.mjs

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Copyright (C) 2026 Pau Aliagas <linuxnow@gmail.com>
+/**
+ * `plugin-qualify-records-package`, the entry point: the Debian package of a device's qualification records. Every
+ * decision is in `src/records-package.ts`; this file reads argv, builds the package, names what stayed out on stderr
+ * and the package on the last line of stdout.
+ */
+import { buildRecordsPackage, parseRecordsPackageArgs, recordsPackageHelp } from "../dist/index.js";
+
+const log = (line) => process.stderr.write(`plugin-qualify-records-package: ${line}\n`);
+
+const parsed = parseRecordsPackageArgs(process.argv.slice(2));
+if (!parsed.ok) {
+  log(parsed.error);
+  process.stderr.write(`\n${recordsPackageHelp()}`);
+  process.exit(2);
+}
+if ("help" in parsed) {
+  process.stdout.write(recordsPackageHelp());
+  process.exit(0);
+}
+let built;
+try {
+  built = buildRecordsPackage(parsed.args);
+} catch (e) {
+  log(e.message);
+  process.exit(2);
+}
+for (const l of built.left) log(`${l.name}: ${l.why}; left out`);
+process.stdout.write(`${built.path}: ${String(built.records)} records, ${String(built.files)} files\n`);

package/bin/plugin-qualify-sync.mjs

@@ -44,7 +44,12 @@ if (!resolved.ok) {
   process.exit(2);
 }
 const s = resolved.settings;
-log(`CLAP ${s.clapDirs.join(":")}; LV2 ${s.lv2Dirs.join(":")}; host ${s.hostProfile.id}; ${String(s.budgetS)} s a plugin`);
+const grid = s.grid.kind === "cells" ? s.grid.cells.map((c) => `${String(c.rate)}/${String(c.quantum)}`).join(",") : s.grid.kind;
+log(
+  `CLAP ${s.clapDirs.join(":")}; LV2 ${s.lv2Dirs.join(":")}; host ${s.hostProfile.id}; grid ${grid}` +
+    `${s.cellsPerPluginBudget > 0 ? ` (first ${String(s.cellsPerPluginBudget)} cells)` : ""}; ${String(s.budgetS)} s a run; ` +
+    `memory ${s.memory === undefined ? "unbounded" : `${String(s.memory.bytes)} bytes`}`,
+);
 try {
   const summary = await runSync(s, { force: parsed.args.force, log });
   if (summary !== undefined) {

package/bin/plugin-qualify.mjs

@@ -35,6 +35,7 @@ import {
   exitCodeFor,
   helpText,
   lv2Loader,
+  memoryBoundOf,
   parseQualifyArgs,
   pinsFile,
   qualificationRecordOf,
@@ -179,7 +180,17 @@ if (parsed.args.all) {
   const lv2 = plugins.filter((p) => p.format === "lv2").length;
   process.stderr.write(`plugin-qualify: --all qualifies ${String(lv2)} LV2 and ${String(plugins.length - lv2)} CLAP plugins on the search paths\n`);
 }
-const pass = qualifyTargets(plugins, { rates: parsed.args.rates, profiles: profiles.profiles });
+const memory = memoryBoundOf(parsed.args.memoryLimit);
+process.stderr.write(`plugin-qualify: memory bound ${memory === undefined ? "off" : `${String(memory.bytes)} bytes (${memory.mechanism})`}\n`);
+const pass = qualifyTargets(plugins, {
+  rates: parsed.args.rates,
+  quanta: parsed.args.quanta,
+  grid: parsed.args.grid,
+  cellsPerPluginBudget: parsed.args.cellsPerPluginBudget,
+  ...(parsed.args.blocks === undefined ? {} : { blocks: parsed.args.blocks }),
+  ...(memory === undefined ? {} : { memory }),
+  profiles: profiles.profiles,
+});
 for (const f of pass.failures) process.stderr.write(`plugin-qualify: ${f.uri}: ${f.problem}\n`);
 if (parsed.args.out !== undefined) {
   for (const run of mergeRunsByRecord(pass.runs)) {

package/dist/distributed-records.d.ts

@@ -0,0 +1,88 @@
+import { type QualificationRecord } from "./qualification-record.js";
+import type { FileDigest, SyncItem, SyncPlugin } from "./qualify-sync.js";
+/** Where a system's packages install the distributed records. */
+export declare const DISTRIBUTED_DIR_SYSTEM = "/usr/share/omx/qualification";
+/** The file of a set that says where its records come from. */
+export declare const DISTRIBUTED_PROVENANCE_FILE = "provenance.json";
+export declare const DISTRIBUTED_PROVENANCE_SCHEMA = "plugin-qualify.distributed-provenance/1";
+/** The first plugin-qualify that reads the layer: what a package of records depends on. */
+export declare const DISTRIBUTED_LAYER_SINCE = "0.17.0";
+/** Where the records of a set come from. The keys below are always there; the rest is what the builder was given. */
+export interface DistributedProvenance {
+    readonly schema: typeof DISTRIBUTED_PROVENANCE_SCHEMA;
+    readonly set: string;
+    readonly hostClass: string;
+    /** The package that installed the set. */
+    readonly package: {
+        readonly name: string;
+        readonly version: string;
+    };
+    /** The day the package was built (YYYY-MM-DD). */
+    readonly date: string;
+    readonly [key: string]: unknown;
+}
+/** The device tree's model file, where a board names itself. */
+export declare const BOARD_MODEL_FILE = "/proc/device-tree/model";
+/** The board's own model, or `undefined` on a machine without a device tree. */
+export declare function readBoardModel(): string | undefined;
+/** The host class of a board the layer knows by its device-tree model: `rpi5` for a Raspberry Pi 5 or its compute module. */
+export declare function hostClassOfBoard(model: string | undefined): string | undefined;
+/** One distributed record, read: where it is, what it says, and the set it came with. */
+export interface DistributedRecord {
+    readonly path: string;
+    readonly record: QualificationRecord;
+    readonly set: string;
+    readonly provenance: DistributedProvenance;
+}
+/** The layer as one run reads it: the records of the host class, by what finds them. */
+export interface DistributedLayer {
+    /** By the `.clap` path the record measured, made absolute. */
+    readonly clap: ReadonlyMap<string, readonly DistributedRecord[]>;
+    /** By the LV2 plugin's uri. */
+    readonly lv2: ReadonlyMap<string, readonly DistributedRecord[]>;
+    readonly sets: readonly string[];
+    readonly records: number;
+}
+export declare const EMPTY_LAYER: DistributedLayer;
+/**
+ * The records of one host class under each directory, in the order given. A set without a provenance that reads, or
+ * whose provenance names another set or class, is not read; a record that does not read as a record of this schema is
+ * named and left out.
+ */
+export declare function readDistributedLayer(dirs: readonly string[], hostClass: string, log?: (line: string) => void): DistributedLayer;
+/** The uri a record's plugin has on this machine: the installed `.clap`'s path and the id, or the LV2 uri. */
+export declare function distributedUri(item: SyncItem, r: DistributedRecord): string;
+/** What the layer makes of one item. */
+export type DistributedMatch = 
+/** No distributed record names the plugin: it is measured, and nothing is said. */
+{
+    readonly status: "none";
+}
+/** Every reason a record found was not taken, one line each; the plugin is measured. */
+ | {
+    readonly status: "ignored";
+    readonly lines: readonly string[];
+} | {
+    readonly status: "applies";
+    readonly set: string;
+    readonly records: readonly DistributedRecord[];
+    readonly files: readonly string[];
+};
+/**
+ * Whether the item is taken from the layer. The records that find it are tried one set at a time, in the order the
+ * layer read them. Of a set, only the records whose every file is installed with the SHA-256 it recorded (computed
+ * here by `digest`) count: a record of other bytes is another build of the plugin and is passed over. The set applies
+ * when at least one record of these bytes holds a verdict for `host`, and none of those verdicts is one the source
+ * could not measure; a set with no record of these bytes is a binary that differs.
+ */
+export declare function matchDistributed(layer: DistributedLayer, item: SyncItem, host: string, digest: (files: readonly string[]) => readonly FileDigest[] | undefined): DistributedMatch;
+/**
+ * The records of a match copied into `qualificationDir` and the plugins they make: the probe output first, byte for
+ * byte and read back through this version's reader, its SHA-256 the one the record names; then the record with the
+ * set's provenance added. A record whose probe output is missing, altered or unreadable throws, naming it, and the
+ * caller measures the plugin instead. Records of the other tier (no verdict for `host`) are copied and make no plugin,
+ * as the sweep writes them.
+ */
+export declare function applyDistributed(qualificationDir: string, item: SyncItem, match: Extract<DistributedMatch, {
+    status: "applies";
+}>, host: string): SyncPlugin[];

package/dist/distributed-records.js

@@ -0,0 +1,210 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Copyright (C) 2026 Pau Aliagas <linuxnow@gmail.com>
+/**
+ * The distributed layer: qualification records another device of the same machine class wrote for a plugin set,
+ * installed read-only under `<dir>/<host class>/<set>/` beside the set's `provenance.json`. plugin-qualify-sync reads
+ * it before measuring a plugin, and takes a plugin from it instead of measuring it only when every file the record
+ * names hashes, here, as it did where it was measured. The name of a plugin finds its record and never decides
+ * anything: a record is never trusted by name alone.
+ *
+ * What applies is copied into the device's own `qualification_dir`, the record with the set's provenance added and
+ * its probe output byte for byte, and the plugin's pin is the one that probe output holds. From then on the sync
+ * treats the plugin as one it measured.
+ */
+import { readFileSync, readdirSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { clapPinUri, pinVerdictOf } from "./pins-file.js";
+import { integrityOfProbeOutput } from "./probe-judge.js";
+import { readProbeOutput, sha256Hex } from "./probe-output.js";
+import { QUALIFICATION_RECORD_SCHEMA } from "./qualification-record.js";
+import { writeFileWhole } from "./whole-file.js";
+/** Where a system's packages install the distributed records. */
+export const DISTRIBUTED_DIR_SYSTEM = "/usr/share/omx/qualification";
+/** The file of a set that says where its records come from. */
+export const DISTRIBUTED_PROVENANCE_FILE = "provenance.json";
+export const DISTRIBUTED_PROVENANCE_SCHEMA = "plugin-qualify.distributed-provenance/1";
+/** The first plugin-qualify that reads the layer: what a package of records depends on. */
+export const DISTRIBUTED_LAYER_SINCE = "0.17.0";
+/** The device tree's model file, where a board names itself. */
+export const BOARD_MODEL_FILE = "/proc/device-tree/model";
+/** The board's own model, or `undefined` on a machine without a device tree. */
+export function readBoardModel() {
+    try {
+        return readFileSync(BOARD_MODEL_FILE, "utf8");
+    }
+    catch {
+        return undefined;
+    }
+}
+/** The host class of a board the layer knows by its device-tree model: `rpi5` for a Raspberry Pi 5 or its compute module. */
+export function hostClassOfBoard(model) {
+    if (model === undefined)
+        return undefined;
+    const m = /^Raspberry Pi (?:Compute Module )?(\d)(?:\s|$)/.exec(model.replace(/\0/g, "").trim());
+    return m === null ? undefined : `rpi${m[1]}`;
+}
+export const EMPTY_LAYER = { clap: new Map(), lv2: new Map(), sets: [], records: 0 };
+const RECORD_SUFFIX = ".qualification.json";
+const names = (dir) => {
+    try {
+        return readdirSync(dir).sort();
+    }
+    catch {
+        return [];
+    }
+};
+/**
+ * The records of one host class under each directory, in the order given. A set without a provenance that reads, or
+ * whose provenance names another set or class, is not read; a record that does not read as a record of this schema is
+ * named and left out.
+ */
+export function readDistributedLayer(dirs, hostClass, log = () => { }) {
+    const clap = new Map();
+    const lv2 = new Map();
+    const sets = [];
+    let records = 0;
+    const add = (map, key, r) => {
+        map.set(key, [...(map.get(key) ?? []), r]);
+    };
+    for (const base of dirs) {
+        const classDir = join(base, hostClass);
+        for (const set of names(classDir)) {
+            const dir = join(classDir, set);
+            let provenance;
+            try {
+                provenance = JSON.parse(readFileSync(join(dir, DISTRIBUTED_PROVENANCE_FILE), "utf8"));
+            }
+            catch (e) {
+                if (e.code === "ENOTDIR")
+                    continue;
+                log(`distributed: ${dir}: ${e.code === "ENOENT" ? `no ${DISTRIBUTED_PROVENANCE_FILE}` : `${DISTRIBUTED_PROVENANCE_FILE} does not read`}, not read`);
+                continue;
+            }
+            if (provenance.schema !== DISTRIBUTED_PROVENANCE_SCHEMA || provenance.set !== set || provenance.hostClass !== hostClass) {
+                log(`distributed: ${dir}: its ${DISTRIBUTED_PROVENANCE_FILE} is not of set ${set} and host class ${hostClass} (${DISTRIBUTED_PROVENANCE_SCHEMA}), not read`);
+                continue;
+            }
+            sets.push(set);
+            for (const name of names(dir)) {
+                if (!name.endsWith(RECORD_SUFFIX))
+                    continue;
+                const path = join(dir, name);
+                let record;
+                try {
+                    record = JSON.parse(readFileSync(path, "utf8"));
+                }
+                catch {
+                    log(`distributed: ${path}: does not read, left out`);
+                    continue;
+                }
+                if (record.schema !== QUALIFICATION_RECORD_SCHEMA || typeof record.binary?.path !== "string" || !Array.isArray(record.binary.files) || record.binary.files.length === 0) {
+                    log(`distributed: ${path}: not a ${QUALIFICATION_RECORD_SCHEMA} with its binary's files, left out`);
+                    continue;
+                }
+                const r = { path, record, set, provenance };
+                records++;
+                if (record.plugin.format === "clap")
+                    add(clap, resolve(record.binary.path), r);
+                else if (record.plugin.format === "lv2")
+                    add(lv2, record.plugin.id, r);
+            }
+        }
+    }
+    return { clap, lv2, sets, records };
+}
+/** The uri a record's plugin has on this machine: the installed `.clap`'s path and the id, or the LV2 uri. */
+export function distributedUri(item, r) {
+    return item.format === "clap" ? clapPinUri(join(item.root, item.files[0]), `urn:clap:${r.record.plugin.id}`) : r.record.plugin.id;
+}
+/** What the sync's own judgment would make of the record's verdict for the host, as `outcomeOf` reads a run. */
+function outcomeOfVerdict(v) {
+    if (!v.measured)
+        return v.deciding === "probe.crashed" ? "crashed" : v.deciding === "probe.timeout" ? "hung" : "unmeasured";
+    if (v.rating === "suitable" || v.rating === "conditional")
+        return "qualified";
+    return v.rating === "unsuitable" ? "refused" : "unmeasured";
+}
+/**
+ * Whether the item is taken from the layer. The records that find it are tried one set at a time, in the order the
+ * layer read them. Of a set, only the records whose every file is installed with the SHA-256 it recorded (computed
+ * here by `digest`) count: a record of other bytes is another build of the plugin and is passed over. The set applies
+ * when at least one record of these bytes holds a verdict for `host`, and none of those verdicts is one the source
+ * could not measure; a set with no record of these bytes is a binary that differs.
+ */
+export function matchDistributed(layer, item, host, digest) {
+    const found = item.format === "clap" ? layer.clap.get(resolve(join(item.root, item.files[0]))) : layer.lv2.get(item.uri ?? "");
+    if (found === undefined || found.length === 0)
+        return { status: "none" };
+    const lines = [];
+    const say = (line) => {
+        if (!lines.includes(line))
+            lines.push(line);
+    };
+    for (const set of [...new Set(found.map((r) => r.set))]) {
+        // a set may hold records of earlier bytes of the plugin beside the ones of these: only the ones of these bytes count
+        const records = found.filter((r) => {
+            if (r.set !== set || r.record.plugin.format !== item.format)
+                return false;
+            const wanted = r.record.binary.files;
+            const now = digest(wanted.map((f) => f.path));
+            return now !== undefined && wanted.every((f) => now.find((d) => d.path === f.path)?.sha256 === f.sha256);
+        });
+        if (records.length === 0) {
+            say(`distributed: ${distributedUri(item, found.find((r) => r.set === set))}: binary differs`);
+            continue;
+        }
+        const judged = records.filter((r) => r.record.verdicts.some((v) => v.host === host));
+        if (judged.length === 0) {
+            say(`distributed: ${distributedUri(item, records[0])}: no verdict for ${host} in ${set}`);
+            continue;
+        }
+        const unmeasured = judged.find((r) => outcomeOfVerdict(r.record.verdicts.find((v) => v.host === host)) === "unmeasured");
+        if (unmeasured !== undefined) {
+            say(`distributed: ${distributedUri(item, unmeasured)}: unmeasured in ${set}, measured here`);
+            continue;
+        }
+        return { status: "applies", set, records, files: [...new Set(records.flatMap((r) => r.record.binary.files.map((f) => f.path)))] };
+    }
+    return { status: "ignored", lines };
+}
+/**
+ * The records of a match copied into `qualificationDir` and the plugins they make: the probe output first, byte for
+ * byte and read back through this version's reader, its SHA-256 the one the record names; then the record with the
+ * set's provenance added. A record whose probe output is missing, altered or unreadable throws, naming it, and the
+ * caller measures the plugin instead. Records of the other tier (no verdict for `host`) are copied and make no plugin,
+ * as the sweep writes them.
+ */
+export function applyDistributed(qualificationDir, item, match, host) {
+    const copies = match.records.map((r) => {
+        const probeName = r.record.probe.file;
+        const probePath = join(r.path, "..", probeName);
+        let bytes;
+        try {
+            bytes = readFileSync(probePath);
+        }
+        catch (e) {
+            throw new Error(`${probeName}: ${e.code ?? String(e)}`);
+        }
+        if (sha256Hex(bytes) !== r.record.probe.sha256)
+            throw new Error(`${probeName}: not the probe output the record names (its SHA-256 differs)`);
+        const read = readProbeOutput(bytes.toString("utf8"));
+        if (!read.ok)
+            throw new Error(`${probeName}: ${read.code}: ${read.problem}`);
+        return { r, bytes, output: read.output };
+    });
+    const plugins = [];
+    for (const { r, bytes, output } of copies) {
+        writeFileWhole(join(qualificationDir, r.record.probe.file), bytes);
+        const recordPath = join(qualificationDir, r.path.slice(r.path.lastIndexOf("/") + 1));
+        writeFileWhole(recordPath, `${JSON.stringify({ ...r.record, provenance: r.provenance }, null, 2)}\n`);
+        const v = r.record.verdicts.find((x) => x.host === host);
+        if (v === undefined)
+            continue;
+        const word = v.measured ? pinVerdictOf(v.rating) : undefined;
+        const pin = { uri: distributedUri(item, r), integrity: integrityOfProbeOutput(output), ...(word === undefined ? {} : { verdict: word }) };
+        const outcome = outcomeOfVerdict(v);
+        plugins.push({ uri: pin.uri, outcome, ...(v.deciding === undefined ? {} : { code: v.deciding }), pin, record: recordPath });
+    }
+    return plugins;
+}
+//# sourceMappingURL=distributed-records.js.map

package/dist/distributed-records.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"distributed-records.js","sourceRoot":"","sources":["../src/distributed-records.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -22,9 +22,14 @@ export * from "./probe-output.js";
 export * from "./probe-judge.js";
 export * from "./qualification-record.js";
 export * from "./probe-runner.js";
+export * from "./measurement-grid.js";
+export * from "./memory-bound.js";
+export * from "./probe-merge.js";
 export * from "./judge-cli.js";
 export * from "./whole-file.js";
 export * from "./qualify-sync.js";
+export * from "./distributed-records.js";
+export * from "./records-package.js";
 export * from "./host-admission.js";
 export * from "./history-file.js";
 export * from "./history-adjust.js";

package/dist/index.js

@@ -24,9 +24,14 @@ export * from "./probe-output.js";
 export * from "./probe-judge.js";
 export * from "./qualification-record.js";
 export * from "./probe-runner.js";
+export * from "./measurement-grid.js";
+export * from "./memory-bound.js";
+export * from "./probe-merge.js";
 export * from "./judge-cli.js";
 export * from "./whole-file.js";
 export * from "./qualify-sync.js";
+export * from "./distributed-records.js";
+export * from "./records-package.js";
 export * from "./host-admission.js";
 export * from "./history-file.js";
 export * from "./history-adjust.js";