@openmixer/plugin-qualify 0.17.5 → 0.18.1

package/fixtures/records-0.16.1/in.lsp-plug.impulse_responses_mono@unversioned-d5235d2f5f53.custom.qualification.json

@@ -0,0 +1,145 @@
+{
+  "schema": "plugin-qualify.qualification-record/1",
+  "plugin": {
+    "format": "clap",
+    "id": "in.lsp-plug.impulse_responses_mono"
+  },
+  "binary": {
+    "path": "/usr/lib/clap/lsp-plugins.clap",
+    "sha256": "d5235d2f5f53eb3641dc9225ff5a912b5eae718cd0abbecd46350dba666f19a2",
+    "files": [
+      {
+        "path": "lsp-plugins.clap",
+        "sha256": "d5235d2f5f53eb3641dc9225ff5a912b5eae718cd0abbecd46350dba666f19a2"
+      }
+    ],
+    "layout": {
+      "scheme": "omx-layout/1",
+      "sha256": "86f71f835f0db0150b6b219b738b97ae0d9d423d2305e29ebdb172b8e20a6381"
+    }
+  },
+  "verdicts": [
+    {
+      "host": "omx-clap-host",
+      "measured": true,
+      "rating": "unsuitable",
+      "qualified": false,
+      "hosting": "isolated",
+      "arm": "declaration",
+      "deciding": "hosting.rt-safety.violations-in-run",
+      "reasons": [
+        {
+          "dimension": "rtSafety",
+          "rating": "unsuitable",
+          "code": "hosting.rt-safety.violations-in-run",
+          "params": {
+            "allocations": 0,
+            "syscalls": 1,
+            "locks": 0
+          }
+        }
+      ]
+    }
+  ],
+  "tiers": {
+    "isolated": {
+      "host": "omx-clap-host",
+      "measured": true,
+      "qualified": false,
+      "rating": "unsuitable",
+      "deciding": "hosting.rt-safety.violations-in-run"
+    },
+    "offeredOn": [],
+    "dimmed": "omx-clap-host: hosting.rt-safety.violations-in-run"
+  },
+  "cost": [
+    {
+      "host": "omx-clap-host",
+      "rate": 48000,
+      "quantum": 128,
+      "reasons": [
+        {
+          "dimension": "cost",
+          "rating": "unknown",
+          "code": "hosting.cost.unmeasured-at-rate-and-quantum",
+          "params": {
+            "rate": 48000,
+            "quantum": 128
+          }
+        }
+      ]
+    }
+  ],
+  "measurements": {
+    "grid": [
+      {
+        "rate": 48000,
+        "quantum": 512,
+        "outcome": "probe.ok",
+        "latency": {
+          "declaredFrames": 0,
+          "measuredFrames": 0
+        },
+        "cost": {
+          "median": 213.506,
+          "percentile": {
+            "p": 95,
+            "value": 230.143
+          },
+          "blocks": 512,
+          "warmupBlocks": 64
+        },
+        "rtSafety": {
+          "interposer": true,
+          "swept": true,
+          "sweepApplicable": true,
+          "blocks": 512,
+          "allocations": 0,
+          "locks": 0,
+          "syscalls": 1,
+          "threadViolations": 0,
+          "processErrors": 0,
+          "events": [
+            "nanosleep"
+          ]
+        },
+        "noteSweep": {
+          "applicable": false
+        }
+      }
+    ]
+  },
+  "notMeasured": [
+    {
+      "dimension": "stability",
+      "code": "hosting.stability.unsoaked"
+    }
+  ],
+  "tool": {
+    "runner": "plugin-hostd-probe 0.13.1",
+    "child": "clap-qualify",
+    "interposer": "rt_interpose.so"
+  },
+  "measuredAt": "2026-10-28T20:56:58+00:00",
+  "probe": {
+    "file": "in.lsp-plug.impulse_responses_mono@unversioned-d5235d2f5f53.custom.probe.json",
+    "sha256": "bc818dfeff46238de3b5558ab8d54aa5677a18f6e3cad79c67bc117313d0a79d",
+    "bytes": 3894,
+    "protocol": {
+      "name": "plugin-hostd.probe-protocol",
+      "version": 1
+    },
+    "reason": "on-request",
+    "outcome": "probe.ok",
+    "complete": true,
+    "machineClass": {
+      "arch": "aarch64",
+      "family": "arm",
+      "coreBand": "3-4",
+      "clockBand": "1.5-2.5GHz",
+      "preemptRt": false,
+      "cstatesLimited": false
+    },
+    "meetsProtocol": false
+  }
+}

package/fixtures/records-0.16.1/in.lsp-plug.trigger_midi_mono@unversioned-d5235d2f5f53.custom.probe.json

@@ -0,0 +1,52 @@
+{
+  "format": "plugin-hostd.probe-output",
+  "formatVersion": "1.1",
+  "run": {
+    "id": "20261028T210152Z-321dd-bb8cc3c7",
+    "startedAt": "2026-10-28T21:01:52+00:00",
+    "elapsedMs": 332,
+    "complete": true,
+    "outcome": "probe.ok",
+    "reason": "on-request",
+    "protocol": {"name": "plugin-hostd.probe-protocol", "version": 1},
+    "tools": {"runner": "plugin-hostd-probe 0.13.1", "child": "clap-qualify", "interposer": "rt_interpose.so"},
+    "via": "runner"
+  },
+  "plugin": {"format": "clap", "id": "in.lsp-plug.trigger_midi_mono"},
+  "binary": {"path": "/usr/lib/clap/lsp-plugins.clap", "sha256": "d5235d2f5f53eb3641dc9225ff5a912b5eae718cd0abbecd46350dba666f19a2", "files": [{"path": "lsp-plugins.clap", "sha256": "d5235d2f5f53eb3641dc9225ff5a912b5eae718cd0abbecd46350dba666f19a2"}], "layout": {"scheme": "omx-layout/1", "sha256": "5a2b073f777379e75dcd931ff9930352d12dcfab9e1fb599d3b1d45d62fe3e1d"}},
+  "machine": {
+    "class": {"arch": "aarch64", "family": "arm", "coreBand": "3-4", "clockBand": "1.5-2.5GHz", "preemptRt": false, "cstatesLimited": false},
+    "profile": {"governor": "powersave", "turbo": false, "smt": false, "preempt": "PREEMPT",
+      "cpuidle": [],
+      "meetsProtocol": false, "unmet": ["probe.profile.governor", "probe.profile.not-pinned"]},
+    "pinnedCpus": "0-3"
+  },
+  "offer": {"id": "custom", "clapExtensions": ["clap.log", "clap.thread-check", "clap.latency", "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", "clap.preset-load/2", "clap.track-info/1", "clap.remote-controls/2"], "realtime": "none"},
+  "limits": {"set": "default",
+    "applied": [
+      {"limit": "wall-clock", "value": 60, "unit": "s", "by": "supervisor"},
+      {"limit": "cpu-time", "value": 540, "unit": "s", "by": "rlimit"},
+      {"limit": "memory", "value": 4294967296, "unit": "bytes", "by": "rlimit"},
+      {"limit": "files", "value": 256, "unit": "count", "by": "rlimit"},
+      {"limit": "file-size", "value": 67108864, "unit": "bytes", "by": "rlimit"},
+      {"limit": "core-dump", "value": 0, "unit": "bytes", "by": "rlimit"},
+      {"limit": "rt-priority", "value": 0, "by": "rlimit"},
+      {"limit": "no-new-privs", "by": "prctl"}
+    ],
+    "unavailable": [
+      {"limit": "tasks", "code": "probe.limit.not-implemented"}
+    ]
+  },
+  "steps": [
+    {"step": "hash", "outcome": "probe.ok", "elapsedMs": 0},
+    {"step": "lifecycle", "outcome": "probe.ok", "elapsedMs": 332, "exitStatus": 0},
+    {"step": "instantiate", "outcome": "probe.ok", "elapsedMs": 0, "detail": "read from the child's line"},
+    {"step": "latency", "rate": 48000, "quantum": 512, "outcome": "probe.ok", "elapsedMs": 0, "detail": "read from the child's line"},
+    {"step": "rt-safety", "outcome": "probe.ok", "elapsedMs": 0, "detail": "counts are totals over every rate, read from the child's line"},
+    {"step": "note-sweep", "outcome": "probe.ok", "elapsedMs": 0, "detail": "counts are totals over every rate, read from the child's line"}
+  ],
+  "grid": [
+    {"rate": 48000, "quantum": 512, "outcome": "probe.ok", "latency": {"declaredFrames": 0, "measuredFrames": 0, "method": "impulse-onset"}, "cost": {"unit": "ns-per-sample", "median": 47.9961, "percentile": {"p": 95, "value": 57.2365}, "min": 31.5742, "max": 114.258, "blocks": 512, "warmupBlocks": 64}, "rtSafety": {"interposer": true, "swept": true, "sweepApplicable": true, "blocks": 512, "allocations": 0, "locks": 0, "syscalls": 0, "threadViolations": 0, "processErrors": 0, "events": []}, "noteSweep": {"applicable": true, "dialect": "midi", "allocations": 0, "locks": 0, "syscalls": 1}}
+  ],
+  "logs": [{"name": "stderr", "path": "/tmp/plugin-qualify-probe-0t8B87/child.stderr.log", "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", "bytes": 0}]
+}

package/fixtures/records-0.16.1/in.lsp-plug.trigger_midi_mono@unversioned-d5235d2f5f53.custom.qualification.json

@@ -0,0 +1,155 @@
+{
+  "schema": "plugin-qualify.qualification-record/1",
+  "plugin": {
+    "format": "clap",
+    "id": "in.lsp-plug.trigger_midi_mono"
+  },
+  "binary": {
+    "path": "/usr/lib/clap/lsp-plugins.clap",
+    "sha256": "d5235d2f5f53eb3641dc9225ff5a912b5eae718cd0abbecd46350dba666f19a2",
+    "files": [
+      {
+        "path": "lsp-plugins.clap",
+        "sha256": "d5235d2f5f53eb3641dc9225ff5a912b5eae718cd0abbecd46350dba666f19a2"
+      }
+    ],
+    "layout": {
+      "scheme": "omx-layout/1",
+      "sha256": "5a2b073f777379e75dcd931ff9930352d12dcfab9e1fb599d3b1d45d62fe3e1d"
+    }
+  },
+  "verdicts": [
+    {
+      "host": "omx-clap-host",
+      "measured": true,
+      "rating": "unsuitable",
+      "qualified": false,
+      "hosting": "isolated",
+      "arm": "declaration",
+      "deciding": "hosting.rt-safety.violations-under-notes",
+      "reasons": [
+        {
+          "dimension": "rtSafety",
+          "rating": "suitable",
+          "code": "hosting.rt-safety.clean-under-sweep",
+          "params": {
+            "blocks": 512
+          }
+        },
+        {
+          "dimension": "rtSafety",
+          "rating": "unsuitable",
+          "code": "hosting.rt-safety.violations-under-notes",
+          "params": {
+            "allocations": 0,
+            "syscalls": 1,
+            "locks": 0
+          }
+        }
+      ]
+    }
+  ],
+  "tiers": {
+    "isolated": {
+      "host": "omx-clap-host",
+      "measured": true,
+      "qualified": false,
+      "rating": "unsuitable",
+      "deciding": "hosting.rt-safety.violations-under-notes"
+    },
+    "offeredOn": [],
+    "dimmed": "omx-clap-host: hosting.rt-safety.violations-under-notes"
+  },
+  "cost": [
+    {
+      "host": "omx-clap-host",
+      "rate": 48000,
+      "quantum": 128,
+      "reasons": [
+        {
+          "dimension": "cost",
+          "rating": "unknown",
+          "code": "hosting.cost.unmeasured-at-rate-and-quantum",
+          "params": {
+            "rate": 48000,
+            "quantum": 128
+          }
+        }
+      ]
+    }
+  ],
+  "measurements": {
+    "grid": [
+      {
+        "rate": 48000,
+        "quantum": 512,
+        "outcome": "probe.ok",
+        "latency": {
+          "declaredFrames": 0,
+          "measuredFrames": 0
+        },
+        "cost": {
+          "median": 47.9961,
+          "percentile": {
+            "p": 95,
+            "value": 57.2365
+          },
+          "blocks": 512,
+          "warmupBlocks": 64
+        },
+        "rtSafety": {
+          "interposer": true,
+          "swept": true,
+          "sweepApplicable": true,
+          "blocks": 512,
+          "allocations": 0,
+          "locks": 0,
+          "syscalls": 0,
+          "threadViolations": 0,
+          "processErrors": 0,
+          "events": []
+        },
+        "noteSweep": {
+          "applicable": true,
+          "dialect": "midi",
+          "allocations": 0,
+          "locks": 0,
+          "syscalls": 1
+        }
+      }
+    ]
+  },
+  "notMeasured": [
+    {
+      "dimension": "stability",
+      "code": "hosting.stability.unsoaked"
+    }
+  ],
+  "tool": {
+    "runner": "plugin-hostd-probe 0.13.1",
+    "child": "clap-qualify",
+    "interposer": "rt_interpose.so"
+  },
+  "measuredAt": "2026-10-28T21:01:52+00:00",
+  "probe": {
+    "file": "in.lsp-plug.trigger_midi_mono@unversioned-d5235d2f5f53.custom.probe.json",
+    "sha256": "17986ad33bc5087175fcce9512761cc28fb66d18beb01598ee2e72b5c5302fa6",
+    "bytes": 3978,
+    "protocol": {
+      "name": "plugin-hostd.probe-protocol",
+      "version": 1
+    },
+    "reason": "on-request",
+    "outcome": "probe.ok",
+    "complete": true,
+    "machineClass": {
+      "arch": "aarch64",
+      "family": "arm",
+      "coreBand": "3-4",
+      "clockBand": "1.5-2.5GHz",
+      "preemptRt": false,
+      "cstatesLimited": false
+    },
+    "meetsProtocol": false
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openmixer/plugin-qualify",
-  "version": "0.17.5",
+  "version": "0.18.1",
   "description": "Qualify audio plugins for real-time hosting: scan, offline latency and cost measurement, and a fail-closed rating.",
   "type": "module",
   "license": "GPL-3.0-or-later",

package/src/clap-qualify.ts

@@ -36,7 +36,7 @@ import {
 import type { QualifyVerdict } from "./qualify-cli.js";
 import { RATING_SEVERITY, worstRating, type SuitabilityRating } from "./rating.js";
 import { halfPopulatedRefusal, locateNativeTools } from "./tool-paths.js";
-import { readIntegrity, type IntegrityMeasurement, type VoicesHeld } from "./measurement/format.js";
+import { readIntegrity, readMemoryFootprint, type IntegrityMeasurement, type MemoryFootprint, type VoicesHeld } from "./measurement/format.js";
 import { isVoiceBasis } from "./measurement/vocabulary.js";
 import { coreFraction } from "./cost-fields.js";
 
@@ -103,6 +103,8 @@ export interface ClapCostReading {
   /** The percentile `nsPerSampleP95` is taken at. */
   readonly percentile: number;
   readonly perRate: Readonly<Record<string, ClapCostAtRate>>;
+  /** What one instance held at each rate (`memory` on the prober's per-rate object), read apart from the timing. */
+  readonly memory?: Readonly<Record<string, MemoryFootprint>>;
 }
 
 /** One plugin's line from `clap-qualify`. */
@@ -285,9 +287,12 @@ function readCost(v: unknown): ClapCostReading {
   const perRateIn = v["perRate"];
   if (!isRecord(perRateIn)) return bad("cost has no perRate map");
   const perRate: Record<string, ClapCostAtRate> = {};
+  const memory: Record<string, MemoryFootprint> = {};
   for (const [rate, at] of Object.entries(perRateIn)) {
     if (!/^[1-9]\d*$/.test(rate)) return bad(`cost rate ${rate}`);
     perRate[rate] = readCostAtRate(at, `cost at ${rate}`, stimulus === "notes-held");
+    const footprint = isRecord(at) ? readMemoryFootprint(at["memory"]) : undefined;
+    if (footprint !== undefined) memory[rate] = footprint;
   }
   return {
     stimulus,
@@ -295,6 +300,7 @@ function readCost(v: unknown): ClapCostReading {
     warmupBlocks: count(v, "warmupBlocks", "cost"),
     percentile: figure(v, "percentile", "cost"),
     perRate,
+    ...(Object.keys(memory).length === 0 ? {} : { memory }),
   };
 }
 
@@ -338,6 +344,7 @@ export function qualifiedPluginOfClapLine(line: ClapQualifyLine, stability?: Plu
     clap,
     rtSafety: { ...rtSafety, noteSweep },
     cpuCost: { perRate: clapCostPerRate(line.cost) },
+    ...(line.cost?.memory === undefined ? {} : { memory: { perRate: line.cost.memory } }),
     ...(stability === undefined ? {} : { stability }),
   };
 }

package/src/direct-limit.ts

@@ -0,0 +1,68 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Copyright (C) 2026 Pau Aliagas <linuxnow@gmail.com>
+/**
+ * The hard limit of a process plugin-qualify spawns directly. Through plugin-hostd's runner a measured child has `memory.max`;
+ * a direct spawn has no runner, so it gets `RLIMIT_AS`, which needs no privilege. It is off for a sanitizer build, which
+ * reserves far more address space than it uses and would fail at start under any limit worth having.
+ *
+ * Hitting the limit is an outcome: the interposer ends the child with `MEMORY_BOUND_EXIT_STATUS` on the first refused
+ * allocation when `MEMORY_BOUND_EXIT_ENV` is set ({@link addressSpaceLimited} sets it), and {@link directOutcome} names it.
+ */
+import { readFileSync } from "node:fs";
+import { totalmem } from "node:os";
+
+import { ADDRESS_SPACE_LIMIT_RAM_FRACTION, MEMORY_BOUND_EXIT_ENV, MEMORY_BOUND_EXIT_STATUS } from "./qualify-declarations.js";
+
+/** The outcome of a direct spawn that hit its limit. */
+export const MEMORY_LIMIT_EXCEEDED = "memory-limit-exceeded";
+export const ADDRESS_SPACE_MECHANISM = "rlimit-as";
+
+const SANITIZER_ENTRY = ["__asan_init", "__tsan_init", "__msan_init"];
+
+/** Whether the program is built with a sanitizer that reserves address space: its own init symbol is in the binary. */
+export function isSanitizerBuild(tool: string, read: (path: string) => Buffer = (p) => readFileSync(p)): boolean {
+  let bytes: Buffer;
+  try {
+    bytes = read(tool);
+  } catch {
+    return false;
+  }
+  return SANITIZER_ENTRY.some((s) => bytes.includes(s));
+}
+
+export interface DirectSpawn {
+  readonly command: string;
+  readonly args: readonly string[];
+  readonly env: Readonly<Record<string, string>>;
+  /** The limit it runs under, in bytes; absent for a sanitizer build. */
+  readonly limitBytes?: number;
+}
+
+/** The limit a direct spawn takes by default: `ADDRESS_SPACE_LIMIT_RAM_FRACTION` of the machine's RAM. */
+export const defaultAddressSpaceLimit = (ramBytes: number = totalmem()): number => Math.floor(ramBytes * ADDRESS_SPACE_LIMIT_RAM_FRACTION);
+
+/**
+ * How to spawn `tool` under the limit: the shell sets it and execs the program, since node has no way to set a child's
+ * rlimit. The program's own process stays the one spawned, so a signal or a timeout reaches it as before.
+ */
+export function addressSpaceLimited(
+  tool: string,
+  args: readonly string[],
+  limitBytes: number = defaultAddressSpaceLimit(),
+  sanitizer: boolean = isSanitizerBuild(tool),
+): DirectSpawn {
+  if (sanitizer) return { command: tool, args, env: {} };
+  const kb = Math.ceil(limitBytes / 2 ** 10);
+  return {
+    command: "/bin/sh",
+    args: ["-c", `ulimit -v ${String(kb)} && exec "$@"`, "sh", tool, ...args],
+    env: { [MEMORY_BOUND_EXIT_ENV]: "1" },
+    limitBytes,
+  };
+}
+
+/** What the end of a direct spawn under a limit comes to: the outcome and the limit when it hit it, else nothing. */
+export function directOutcome(status: number | null, spawn: DirectSpawn): { readonly outcome: string; readonly memoryLimit: { readonly bytes: number; readonly mechanism: string } } | undefined {
+  if (spawn.limitBytes === undefined || status !== MEMORY_BOUND_EXIT_STATUS) return undefined;
+  return { outcome: MEMORY_LIMIT_EXCEEDED, memoryLimit: { bytes: spawn.limitBytes, mechanism: ADDRESS_SPACE_MECHANISM } };
+}

package/src/distributed-records.ts

@@ -153,7 +153,7 @@ export function distributedUri(item: SyncItem, r: DistributedRecord): string {
 }
 
 /** What the sync's own judgment would make of the record's verdict for the host, as `outcomeOf` reads a run. */
-function outcomeOfVerdict(v: RecordVerdict): SyncOutcome {
+export function outcomeOfVerdict(v: Pick<RecordVerdict, "measured" | "rating" | "deciding">): SyncOutcome {
   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";

package/src/host-admission.ts

@@ -12,6 +12,7 @@ import { spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
 
 import type { HostProfile } from "./host-profiles.js";
+import { ADMIT_STEP_MS_ENV } from "./qualify-declarations.js";
 
 /** The profile ids whose verdict is measured by a run. */
 export const ADMITTED_HOSTS = ["mod-host", "jalv"] as const;
@@ -24,11 +25,23 @@ export function admittedHostOf(profile: HostProfile): AdmittedHost | undefined {
 
 /**
  * plugin-hostd's LV2 adapter, omx-clap-host: an LV2 plugin is run under it once, as under mod-host, and the record
- * carries the outcome as its own step beside the verdicts (plugin-qualify#223), which it does not change: the
- * omx-clap-host verdict of an LV2 plugin stays the in-process measurement. It is what the removal of mod-host counts.
+ * carries the outcome as its own step (plugin-qualify#223). The run decides the omx-clap-host verdict of an LV2
+ * plugin, the isolated tier, as a mod-host run decides mod-host's; a CLAP plugin's stays the measurement.
  */
 export const ADAPTER_HOST = "omx-clap-host";
 
+/** The profiles whose LV2 plugins run under that adapter: omx-clap-host, and the Pi boards it runs on (`host-profiles.ts`). */
+export const ADAPTER_RUN_HOSTS: readonly string[] = [ADAPTER_HOST, "openmixer-pi-4gb", "openmixer-pi-8gb"];
+
+/**
+ * Whether this run decides the profile's verdict for a plugin of this format. A mod-host or jalv run always does, an
+ * unmeasured one making the verdict unknown; the adapter's only when it measured, since the omx-clap-host verdict
+ * otherwise stands on the measurement.
+ */
+export function runDecides(profile: HostProfile, format: string, admission: HostAdmission): boolean {
+  return admittedHostOf(profile) !== undefined || (ADAPTER_RUN_HOSTS.includes(profile.id) && format === "lv2" && admission.measured);
+}
+
 /** What running the plugin under one host came to. */
 export interface HostAdmission {
   readonly host: AdmittedHost | typeof ADAPTER_HOST;
@@ -62,12 +75,16 @@ export interface ModHostStep {
 /** What `tools/mod-host-admit.mjs` printed. */
 export interface ModHostRun {
   readonly installed: boolean;
+  /** False when the host never took a connection (omx-clap-host with no JACK server): no plugin was loaded. */
+  readonly started?: boolean;
   readonly steps: readonly ModHostStep[];
 }
 
 /** The verdict of a run of a host that speaks mod-host's protocol: the first step that did not answer `resp 0` decides. */
 export function classifyProtocolRun(host: ProtocolHost, run: ModHostRun): HostAdmission {
   if (!run.installed) return notInstalled(host);
+  // the host never listened, so the plugin was never loaded: nothing was learned about it
+  if (run.started === false) return { host, measured: false, admitted: false, code: `${host}.not-started`, params: {} };
   for (const s of run.steps) {
     if (s.died !== undefined) {
       if (s.died.startsWith("SIG")) return refused(host, `signal-${s.died}`, { step: s.cmd });
@@ -131,7 +148,10 @@ const MOD_HOST_ADMIT = fileURLToPath(new URL("../tools/mod-host-admit.mjs", impo
 /** The runs against the installed hosts. */
 export const SPAWNED_ADMISSIONS: AdmissionRuns = {
   adapter(uri, env) {
-    const r = spawnSync(process.execPath, [MOD_HOST_ADMIT, uri, ADAPTER_HOST], { encoding: "utf8", timeout: MOD_HOST_ADMISSION_MS, ...(env === undefined ? {} : { env: { ...env } }) });
+    // two commands at the limit the pass gives each, and the tool's own start and end: it kills the host itself first
+    const stepMs = Number(env?.[ADMIT_STEP_MS_ENV] ?? 0);
+    const timeout = stepMs > 0 ? 2 * stepMs + 15000 : MOD_HOST_ADMISSION_MS;
+    const r = spawnSync(process.execPath, [MOD_HOST_ADMIT, uri, ADAPTER_HOST], { encoding: "utf8", timeout, killSignal: "SIGKILL", ...(env === undefined ? {} : { env: { ...env } }) });
     if (r.error !== undefined || r.status !== 0) {
       throw new Error(`${ADAPTER_HOST} admission of ${uri} gave no answer (${r.error?.message ?? `exit ${String(r.status)}`}): ${(r.stderr ?? "").trim()}`);
     }
@@ -145,7 +165,10 @@ export const SPAWNED_ADMISSIONS: AdmissionRuns = {
     return JSON.parse(r.stdout) as ModHostRun;
   },
   jalv(uri, env) {
-    const r = spawnSync("jalv", ["-n", "plugin-qualify", uri], { encoding: "utf8", timeout: JALV_HOSTED_MS, input: "", ...(env === undefined ? {} : { env: { ...env } }) });
+    // SIGKILL at the deadline: jalv hosting some plugins ignores SIGTERM, and one stuck in jack_client_open never reaches
+    // the loop that reads the flag TERM sets, so a TERM left spawnSync waiting with it (#187). Alive at the deadline is
+    // all the verdict asks, so nothing is lost by not letting it exit cleanly.
+    const r = spawnSync("jalv", ["-n", "plugin-qualify", uri], { encoding: "utf8", timeout: JALV_HOSTED_MS, killSignal: "SIGKILL", input: "", ...(env === undefined ? {} : { env: { ...env } }) });
     const code = (r.error as NodeJS.ErrnoException | undefined)?.code;
     if (code === "ENOENT") return { installed: false, stillRunning: false, status: null, signal: null, stderr: "" };
     return { installed: true, stillRunning: code === "ETIMEDOUT", status: r.status, signal: code === "ETIMEDOUT" ? null : r.signal, stderr: r.stderr ?? "" };

package/src/host-profiles.ts

@@ -164,8 +164,24 @@ export const OMX_CLAP_HOST_PROFILE: HostProfile = {
   isolation: "shared-process",
 };
 
+/**
+ * A Raspberry Pi with 4 GB, and with 8 GB: what runs a plugin there is omx-clap-host under plugin-hostd, so the same
+ * extensions, instruments and isolation, on the rates, quanta and memory of the board. Its memory budget is provisional
+ * ({@link HOST_BUDGETS}), so a plugin under it is `conditional` until the numbers are measured on a Pi, and the reason says
+ * so. Judged at every cell the board runs.
+ */
+export const PI_4GB_PROFILE: HostProfile = { ...OMX_CLAP_HOST_PROFILE, id: "openmixer-pi-4gb", cost: HOST_BUDGETS["openmixer-pi-4gb"] };
+export const PI_8GB_PROFILE: HostProfile = { ...OMX_CLAP_HOST_PROFILE, id: "openmixer-pi-8gb", cost: HOST_BUDGETS["openmixer-pi-8gb"] };
+
 /** Every profile the tool ships, by id. */
-export const HOST_PROFILES: readonly HostProfile[] = [OPENMIXER_CONSOLE_PROFILE, JALV_PROFILE, MOD_HOST_PROFILE, OMX_CLAP_HOST_PROFILE];
+export const HOST_PROFILES: readonly HostProfile[] = [
+  OPENMIXER_CONSOLE_PROFILE,
+  JALV_PROFILE,
+  MOD_HOST_PROFILE,
+  OMX_CLAP_HOST_PROFILE,
+  PI_4GB_PROFILE,
+  PI_8GB_PROFILE,
+];
 
 /** A shipped profile by id, or `undefined`. */
 export function shippedHostProfile(id: string): HostProfile | undefined {

package/src/hosting-codes.generated.ts

@@ -32,6 +32,10 @@ export const HOSTING_CODE = Object.freeze({
   "latencyParameterDependent": "hosting.latency.parameter-dependent",
   "latencyResolved": "hosting.latency.resolved",
   "latencyUnmeasured": "hosting.latency.unmeasured",
+  "memoryAboveCeiling": "hosting.memory.above-ceiling",
+  "memoryUnmeasured": "hosting.memory.unmeasured",
+  "memoryWithinCeiling": "hosting.memory.within-ceiling",
+  "memoryWithinProvisionalCeiling": "hosting.memory.within-provisional-ceiling",
   "outputNonFinite": "hosting.output.non-finite",
   "overrideIsolated": "hosting.override.curator-isolated",
   "patchBusy": "hosting.patch.busy",
@@ -45,6 +49,9 @@ export const HOSTING_CODE = Object.freeze({
   "noRealisation": "hosting.no-realisation",
   "realisedInProcess": "hosting.realised.in-process",
   "unjudged": "hosting.unjudged",
+  "resourceHintsOutOfRange": "hosting.resource-hints.out-of-range",
+  "resourceHintsUnknownHint": "hosting.resource-hints.unknown-hint",
+  "resourceHintsWrongUnit": "hosting.resource-hints.wrong-unit",
   "rtSafetyClean": "hosting.rt-safety.clean-under-sweep",
   "rtSafetyNotReproducible": "hosting.rt-safety.not-reproducible",
   "rtSafetyNotesClean": "hosting.rt-safety.clean-under-notes",
@@ -81,4 +88,7 @@ export const HOSTING_CODE = Object.freeze({
   "topologyWiderThanStrip": "hosting.topology.wider-than-strip",
   "workerNonconforming": "hosting.worker.nonconforming",
   "idleHoldRefused": "hosting.idle.hold-refused",
+  "windowNoDisplay": "hosting.window.no-display",
+  "windowUnsupported": "hosting.window.unsupported",
+  "windowRefused": "hosting.window.refused",
 } as const);