@openmixer/plugin-qualify 0.0.0-stage → 0.3.0

package/dist/hosting-codes.d.ts

@@ -0,0 +1,62 @@
+/**
+ * The hosting verdict's message codes (2026-09-04-lv2-hosting-path.md). Codes, never prose: the
+ * surface renders the operator's locale.
+ *
+ * A UNION list file (2026-09-15-no-stored-derivations.md §9): `.gitattributes` marks it
+ * `merge=union`, so two lanes that each add a code merge with both kept. Only the table lives
+ * here, one `key: 'code',` per line, with keys and codes unique; the registry-hotspots gate
+ * refuses anything else.
+ */
+export declare const HOSTING_CODE: {
+    readonly stabilitySoaked: "hosting.stability.soaked";
+    readonly stabilityCrashedAttributed: "hosting.stability.crashed-attributed-plugin";
+    readonly stabilityCrashedLive: "hosting.stability.crashed-live-on-this-rig";
+    readonly stabilityBelowFloor: "hosting.stability.cycles-below-floor";
+    readonly stabilityUnsoaked: "hosting.stability.unsoaked";
+    readonly stabilityUnmeasured: "hosting.stability.unmeasured";
+    readonly stabilityCrashUnattributed: "hosting.stability.crash-unattributed";
+    readonly stabilitySpawnsThreads: "hosting.stability.spawns-threads";
+    readonly stabilityLinksGuiToolkit: "hosting.stability.links-gui-toolkit";
+    readonly rtSafetyClean: "hosting.rt-safety.clean-under-sweep";
+    readonly rtSafetyViolations: "hosting.rt-safety.violations-in-run";
+    readonly rtSafetyUnmeasured: "hosting.rt-safety.unmeasured";
+    readonly rtSafetyNotReproducible: "hosting.rt-safety.not-reproducible";
+    readonly featuresProvided: "hosting.features.all-provided";
+    readonly featuresMissing: "hosting.features.required-not-provided";
+    readonly featuresDisqualifying: "hosting.features.host-not-provided";
+    readonly featuresCv: "hosting.features.cv-ports";
+    readonly featuresMidiIn: "hosting.features.midi-in-fed-empty";
+    readonly featuresUnscanned: "hosting.features.scan-predates-field";
+    readonly costWithinCeiling: "hosting.cost.within-ceiling";
+    readonly costAboveCeiling: "hosting.cost.above-ceiling";
+    readonly costSpiky: "hosting.cost.spiky-tail";
+    readonly costUnmeasured: "hosting.cost.unmeasured-at-rate-and-quantum";
+    readonly latencyResolved: "hosting.latency.resolved";
+    readonly latencyUnmeasured: "hosting.latency.unmeasured";
+    readonly latencyNonconforming: "hosting.latency.nonconforming";
+    readonly latencyParameterDependent: "hosting.latency.parameter-dependent";
+    readonly topologyMatched: "hosting.topology.matched";
+    readonly topologyNoAudioInput: "hosting.topology.no-audio-input";
+    readonly topologyNoAudioOutput: "hosting.topology.no-audio-output";
+    readonly topologyExtraInputs: "hosting.topology.extra-inputs-fed-silence";
+    readonly topologyInstrument: "hosting.topology.instrument";
+    readonly topologyWiderThanStrip: "hosting.topology.wider-than-strip";
+    readonly clapLatencyMismatch: "hosting.clap.latency-mismatch";
+    readonly clapNotAudioEffect: "hosting.clap.not-audio-effect";
+    readonly clapHeadlessFailed: "hosting.clap.headless-failed";
+    readonly clapNoteInput: "hosting.clap.note-input";
+    readonly clapThreadViolation: "hosting.clap.thread-violation";
+    readonly clapProcessError: "hosting.clap.process-error";
+    readonly clapUnqualified: "hosting.clap.unqualified";
+    readonly clapFormatNotHosted: "hosting.clap.format-not-hosted";
+    readonly clapExtensionsNotCovered: "hosting.clap.extensions-not-covered";
+    readonly outputNonFinite: "hosting.output.non-finite";
+    readonly overrideIsolated: "hosting.override.curator-isolated";
+    readonly hostProvenanceDiffers: "hosting.provenance.host-differs";
+    readonly sweepControlDidNotFire: "hosting.provenance.sweep-control-did-not-fire";
+    readonly disabled: "hosting.disabled";
+    readonly unjudged: "hosting.unjudged";
+    readonly noRealisation: "hosting.no-realisation";
+    readonly realisedInProcess: "hosting.realised.in-process";
+    readonly linked: "hosting.linked";
+};

package/dist/hosting-codes.js

@@ -0,0 +1,72 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Copyright (C) 2026 Pau Aliagas <linuxnow@gmail.com>
+/**
+ * The hosting verdict's message codes (2026-09-04-lv2-hosting-path.md). Codes, never prose: the
+ * surface renders the operator's locale.
+ *
+ * A UNION list file (2026-09-15-no-stored-derivations.md §9): `.gitattributes` marks it
+ * `merge=union`, so two lanes that each add a code merge with both kept. Only the table lives
+ * here, one `key: 'code',` per line, with keys and codes unique; the registry-hotspots gate
+ * refuses anything else.
+ */
+export const HOSTING_CODE = {
+    stabilitySoaked: 'hosting.stability.soaked',
+    stabilityCrashedAttributed: 'hosting.stability.crashed-attributed-plugin',
+    stabilityCrashedLive: 'hosting.stability.crashed-live-on-this-rig',
+    stabilityBelowFloor: 'hosting.stability.cycles-below-floor',
+    stabilityUnsoaked: 'hosting.stability.unsoaked',
+    stabilityUnmeasured: 'hosting.stability.unmeasured',
+    stabilityCrashUnattributed: 'hosting.stability.crash-unattributed',
+    stabilitySpawnsThreads: 'hosting.stability.spawns-threads',
+    stabilityLinksGuiToolkit: 'hosting.stability.links-gui-toolkit',
+    rtSafetyClean: 'hosting.rt-safety.clean-under-sweep',
+    rtSafetyViolations: 'hosting.rt-safety.violations-in-run',
+    rtSafetyUnmeasured: 'hosting.rt-safety.unmeasured',
+    rtSafetyNotReproducible: 'hosting.rt-safety.not-reproducible',
+    featuresProvided: 'hosting.features.all-provided',
+    featuresMissing: 'hosting.features.required-not-provided',
+    featuresDisqualifying: 'hosting.features.host-not-provided',
+    featuresCv: 'hosting.features.cv-ports',
+    featuresMidiIn: 'hosting.features.midi-in-fed-empty',
+    featuresUnscanned: 'hosting.features.scan-predates-field',
+    costWithinCeiling: 'hosting.cost.within-ceiling',
+    costAboveCeiling: 'hosting.cost.above-ceiling',
+    costSpiky: 'hosting.cost.spiky-tail',
+    costUnmeasured: 'hosting.cost.unmeasured-at-rate-and-quantum',
+    latencyResolved: 'hosting.latency.resolved',
+    latencyUnmeasured: 'hosting.latency.unmeasured',
+    latencyNonconforming: 'hosting.latency.nonconforming',
+    latencyParameterDependent: 'hosting.latency.parameter-dependent',
+    topologyMatched: 'hosting.topology.matched',
+    topologyNoAudioInput: 'hosting.topology.no-audio-input',
+    topologyNoAudioOutput: 'hosting.topology.no-audio-output',
+    topologyExtraInputs: 'hosting.topology.extra-inputs-fed-silence',
+    topologyInstrument: 'hosting.topology.instrument',
+    // The CLAP arm (2026-09-26-clap-hosting-path.md §3): the SAME dimensions fed from CLAP facts,
+    // minted here where the LV2 table has no code for the fact.
+    topologyWiderThanStrip: 'hosting.topology.wider-than-strip',
+    clapLatencyMismatch: 'hosting.clap.latency-mismatch',
+    clapNotAudioEffect: 'hosting.clap.not-audio-effect',
+    clapHeadlessFailed: 'hosting.clap.headless-failed',
+    clapNoteInput: 'hosting.clap.note-input',
+    clapThreadViolation: 'hosting.clap.thread-violation',
+    clapProcessError: 'hosting.clap.process-error',
+    clapUnqualified: 'hosting.clap.unqualified',
+    clapFormatNotHosted: 'hosting.clap.format-not-hosted',
+    clapExtensionsNotCovered: 'hosting.clap.extensions-not-covered',
+    outputNonFinite: 'hosting.output.non-finite',
+    overrideIsolated: 'hosting.override.curator-isolated',
+    hostProvenanceDiffers: 'hosting.provenance.host-differs',
+    sweepControlDidNotFire: 'hosting.provenance.sweep-control-did-not-fire',
+    // The five REALISED reasons. Everything above answers what a plugin EARNED; these answer
+    // what the console DID with that, and the difference between the two is the operator's
+    // whole question when a slot is not on the fast path.
+    disabled: 'hosting.disabled',
+    unjudged: 'hosting.unjudged',
+    noRealisation: 'hosting.no-realisation',
+    realisedInProcess: 'hosting.realised.in-process',
+    // A plugin LINKED into the engine (the static-link registry) runs in-process without a
+    // verdict: the library's oracles are its proof (`2026-09-26-clap-hosting-path.md` §7).
+    linked: 'hosting.linked',
+};
+//# sourceMappingURL=hosting-codes.js.map

package/dist/hosting-codes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hosting-codes.js","sourceRoot":"","sources":["../src/hosting-codes.ts"],"names":[],"mappings":"AAAA,4CAA4C;AAC5C,sDAAsD;AACtD;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG;IAC1B,eAAe,EAAE,0BAA0B;IAC3C,0BAA0B,EAAE,6CAA6C;IACzE,oBAAoB,EAAE,4CAA4C;IAClE,mBAAmB,EAAE,sCAAsC;IAC3D,iBAAiB,EAAE,4BAA4B;IAC/C,mBAAmB,EAAE,8BAA8B;IACnD,0BAA0B,EAAE,sCAAsC;IAClE,sBAAsB,EAAE,kCAAkC;IAC1D,wBAAwB,EAAE,qCAAqC;IAC/D,aAAa,EAAE,qCAAqC;IACpD,kBAAkB,EAAE,qCAAqC;IACzD,kBAAkB,EAAE,8BAA8B;IAClD,uBAAuB,EAAE,oCAAoC;IAC7D,gBAAgB,EAAE,+BAA+B;IACjD,eAAe,EAAE,wCAAwC;IACzD,qBAAqB,EAAE,oCAAoC;IAC3D,UAAU,EAAE,2BAA2B;IACvC,cAAc,EAAE,oCAAoC;IACpD,iBAAiB,EAAE,sCAAsC;IACzD,iBAAiB,EAAE,6BAA6B;IAChD,gBAAgB,EAAE,4BAA4B;IAC9C,SAAS,EAAE,yBAAyB;IACpC,cAAc,EAAE,6CAA6C;IAC7D,eAAe,EAAE,0BAA0B;IAC3C,iBAAiB,EAAE,4BAA4B;IAC/C,oBAAoB,EAAE,+BAA+B;IACrD,yBAAyB,EAAE,qCAAqC;IAChE,eAAe,EAAE,0BAA0B;IAC3C,oBAAoB,EAAE,iCAAiC;IACvD,qBAAqB,EAAE,kCAAkC;IACzD,mBAAmB,EAAE,2CAA2C;IAChE,kBAAkB,EAAE,6BAA6B;IACjD,8FAA8F;IAC9F,4DAA4D;IAC5D,sBAAsB,EAAE,mCAAmC;IAC3D,mBAAmB,EAAE,+BAA+B;IACpD,kBAAkB,EAAE,+BAA+B;IACnD,kBAAkB,EAAE,8BAA8B;IAClD,aAAa,EAAE,yBAAyB;IACxC,mBAAmB,EAAE,+BAA+B;IACpD,gBAAgB,EAAE,4BAA4B;IAC9C,eAAe,EAAE,0BAA0B;IAC3C,mBAAmB,EAAE,gCAAgC;IACrD,wBAAwB,EAAE,qCAAqC;IAC/D,eAAe,EAAE,2BAA2B;IAC5C,gBAAgB,EAAE,mCAAmC;IACrD,qBAAqB,EAAE,iCAAiC;IACxD,sBAAsB,EAAE,+CAA+C;IACvE,yFAAyF;IACzF,uFAAuF;IACvF,sDAAsD;IACtD,QAAQ,EAAE,kBAAkB;IAC5B,QAAQ,EAAE,kBAAkB;IAC5B,aAAa,EAAE,wBAAwB;IACvC,iBAAiB,EAAE,6BAA6B;IAChD,uFAAuF;IACvF,uFAAuF;IACvF,MAAM,EAAE,gBAAgB;CAChB,CAAC"}

package/dist/hosting-suitability.d.ts

@@ -0,0 +1,354 @@
+/**
+ * Which HOST a plugin has earned: the console's own RT thread, or a `mod-host` process.
+ *
+ * "Thoroughly tested" is not a hand list and never an author's opinion. It is the derived
+ * verdict `hosting.rating === "suitable"`, computed on every read from measurements the
+ * catalog holds. `path` follows the rating and nothing else: `suitable` earns `in-process`,
+ * every rating below it is `isolated` with the reasons that decided it.
+ *
+ * The shape mirrors {@link import('./destination-suitability.js').classifyForRole} because
+ * the same law governs both — a standing is DERIVED, absence is an admission rather than a
+ * pass, and an override may only ever demote. What differs is the stake. A destination
+ * verdict that is wrong puts a reverb in a wedge; a hosting verdict that is wrong puts an
+ * untested plugin on the thread the whole desk's audio runs on, where its crash is not its
+ * own. So every dimension here fails CLOSED: no measurement means `unknown`, and `unknown`
+ * means isolated.
+ */
+import { type SuitabilityKind, type SuitabilityRating } from "./rating.js";
+import type { FeaturesMeasurement, LifecycleReading, RtSafetyMeasurement, SoakReading, ThreadReading } from "./measurement/format.js";
+/**
+ * What a reason may interpolate: wire-serialisable scalars only. Structurally the same record as
+ * the console's coded-refusal parameters, so a consumer passes it straight through.
+ */
+export type CodedRefusalParams = Readonly<Record<string, string | number>>;
+/**
+ * The plugin the rating reads — exactly the fields it judges, and nothing a host's own catalog
+ * adds. The console's plugin descriptor satisfies it structurally; the standalone CLI
+ * builds it from the scan and the interchange document.
+ */
+export interface QualifiedPlugin {
+    readonly audioInputs: number;
+    readonly audioOutputs: number;
+    readonly hasMidiIn: boolean;
+    /** The benchmark's latency block; only whether it resolved, conforms and moves is read. */
+    readonly latency?: {
+        readonly unmeasurable?: unknown;
+        readonly scalingClass?: string;
+        readonly paramSweep?: unknown;
+    };
+    /** Measured cost per rate (Hz as a string key). */
+    readonly cpuCost?: {
+        readonly perRate?: Readonly<Record<string, {
+            readonly coreFractionP95: number;
+            readonly nsPerSampleMedian: number;
+            readonly nsPerSampleP95: number;
+        }>>;
+    };
+    readonly stability?: PluginStabilityMeasurement;
+    readonly rtSafety?: PluginRtSafetyMeasurement;
+    readonly lv2Features?: PluginLv2Features;
+    /** The plugin's binary format, the scan's declared fact (CLAP spec §6); absent reads `lv2`. */
+    readonly format?: "lv2" | "clap";
+    /** What the CLAP prober (`native/clap-qualify`) measured, for a `clap` plugin (CLAP spec §3). */
+    readonly clap?: PluginClapMeasurement;
+}
+/** Where a plugin's audio is actually processed. */
+export type HostingPath = "in-process" | "isolated";
+/** The dimensions that decide a host. Six, folded worst-wins. */
+export type HostingDimension = "stability" | "rtSafety" | "features" | "cost" | "latency" | "topology";
+export { OMX_CLAP_HOST_EXTENSIONS, OMX_INPROCESS_FEATURES, OPENMIXER_CONSOLE_PROFILE, type HostProfile } from "./host-profiles.js";
+import { type HostProfile } from "./host-profiles.js";
+/** The catalog key of a CLAP plugin is `urn:clap:<clap_plugin_descriptor.id>` (CLAP spec §6). */
+export declare const CLAP_URI_PREFIX = "urn:clap:";
+/** Whether `uri` is a CLAP catalog key — the key grammar, for a plugin the catalog may not hold. */
+export declare function isClapUri(uri: string): boolean;
+/**
+ * Whether the plugin `uri` names is hosted through the CLAP path: the descriptor's DECLARED
+ * format where the catalog holds one, else the key grammar (a `urn:clap:` uri the catalog never
+ * scanned is still a CLAP the console has no LV2 host for).
+ */
+export declare function isClapPlugin(uri: string, descriptor: Pick<QualifiedPlugin, "format"> | undefined): boolean;
+/** The CLAP descriptor feature that makes a plugin an audio effect (`clap/plugin-features.h`). */
+export declare const CLAP_FEATURE_AUDIO_EFFECT = "audio-effect";
+/** The CLAP descriptor feature that makes a plugin an instrument (`clap/plugin-features.h`). */
+export declare const CLAP_FEATURE_INSTRUMENT = "instrument";
+/** The verdict's message codes, declared in their union list file. */
+import { HOSTING_CODE } from "./hosting-codes.js";
+export { HOSTING_CODE };
+export type HostingCode = (typeof HOSTING_CODE)[keyof typeof HOSTING_CODE];
+/**
+ * The refusals libomx-clap-core returns from `open`, `activate` and the timed open, each named by the KEY of the
+ * `HOSTING_CODE` it answers with — never by the string, so no second spelling of a code exists. The console's
+ * generator renders them into omx-clap-host's `clap_host_limits.h` as `CLAP_HOST_CODE_<NAME>`, the left column's
+ * name in upper snake case. The facts the qualifier judges from a measurement (latency, thread violations, process
+ * errors, RT safety) are the console's and are not here.
+ */
+export declare const CLAP_CORE_REFUSALS: {
+    readonly headlessFailed: "clapHeadlessFailed";
+    readonly notAudioEffect: "clapNotAudioEffect";
+    readonly noteInput: "clapNoteInput";
+    readonly noAudioInput: "topologyNoAudioInput";
+    readonly noAudioOutput: "topologyNoAudioOutput";
+    readonly widerThanStrip: "topologyWiderThanStrip";
+    readonly extraInputs: "topologyExtraInputs";
+    readonly crashedLive: "stabilityCrashedLive";
+    readonly outputNonFinite: "outputNonFinite";
+};
+/** One dimension's answer for one plugin. */
+export interface HostingReason {
+    readonly dimension: HostingDimension;
+    readonly kind: SuitabilityKind;
+    readonly rating: SuitabilityRating;
+    readonly code: HostingCode;
+    readonly params: CodedRefusalParams;
+}
+/**
+ * What a reason may contribute. Unlike the destination classifier, every reason here is
+ * objective — there is no taste in whether a plugin allocates inside `run()`. The cautions
+ * that look advisory (`spawns-threads`, `links-gui-toolkit`) are MEASURED facts, so they are
+ * objective too and cap the plugin at `conditional` by their own rating rather than by a kind
+ * rule. An advisory reason, if one is ever added, may never do worse than `conditional`.
+ */
+export declare function contributedHostingRating(reason: HostingReason): SuitabilityRating;
+/** How a crash was attributed. `unknown` is the default and derives `unknown`, never blame. */
+export type CrashAttribution = "plugin" | "host" | "unknown";
+/** One row of the signature table: a crash shape we have seen and named. */
+export interface CrashSignature {
+    readonly id: string;
+    readonly attribution: CrashAttribution;
+    /** The top plugin-owned stack frame, or a host frame that exonerates the plugin. */
+    readonly topFrame: string;
+    readonly signal?: "SIGSEGV" | "SIGABRT" | "SIGBUS";
+    /** The note that recorded this cluster. Provenance, so a row is never folklore. */
+    readonly note: string;
+}
+/**
+ * Seeded from the crash notes of 2026-09-03/04. A raw crash matching NO row is
+ * `unknown` — the table blames a plugin only where a named investigation did.
+ */
+export declare const CRASH_SIGNATURES: readonly CrashSignature[];
+/** A crash as observed, before attribution. */
+export interface ObservedCrash {
+    readonly signal?: "SIGSEGV" | "SIGABRT" | "SIGBUS";
+    readonly topFrame?: string;
+    /** The sanitizer's error class, when a sanitizer build caught it (interchange §3a). */
+    readonly sanitizer?: string;
+    /** Basename of the object the faulting frame lies in. */
+    readonly frameObject?: string;
+}
+/**
+ * Map a raw crash to blame. Fails to `unknown`: a signature must match the frame AND, where
+ * the row names one, the signal. An unmatched crash never reads as the plugin's fault.
+ */
+export declare function attributeCrash(crash: ObservedCrash, table?: readonly CrashSignature[], pluginBinary?: string): CrashAttribution;
+/**
+ * What a lifecycle sweep MEASURED about a plugin surviving — the interchange format's stability
+ * block as it lands on a descriptor (`measurement-catalog.ts`), RAW: the cycles as run, the
+ * threads as counted, the crashes as observed, the soak per rate as rendered. Whether any of that
+ * adds up to a pass is {@link stabilityReasons}' to say, and nobody else's.
+ */
+export interface PluginStabilityMeasurement {
+    readonly lifecycle?: LifecycleReading;
+    readonly threads?: ThreadReading;
+    readonly crashes?: readonly ObservedCrash[];
+    /** A continuous render per rate with the controls swept — judged at EVERY rate it ran. */
+    readonly soak?: SoakReading;
+    readonly linksGuiToolkit?: boolean;
+    /** Recorded when a live console's pre-rack trial or a show killed it. */
+    readonly crashedLive?: boolean;
+    /** The host the figures were taken on — the run's, set by the door that landed them. */
+    readonly runHost?: string;
+}
+/**
+ * The interposer's counts inside `run()`, RAW, with the pair it ran at and the flags that say
+ * whether the count is a measurement at all ({@link rtSafetyMeasured}) — the interchange's
+ * rt-safety block as it lands, minus the reason a block with no reading carries instead.
+ */
+export type PluginRtSafetyMeasurement = Omit<RtSafetyMeasurement, "unmeasuredReason" | "unmeasuredDetail">;
+/** What the plugin DEMANDS of a host, read off the instance the sweep loaded. */
+export type PluginLv2Features = Omit<FeaturesMeasurement, "unmeasuredReason" | "unmeasuredDetail">;
+export { DEFAULT_HOSTING_POLICY, type HostingPolicy } from "./qualify-declarations.js";
+import { type HostingPolicy } from "./qualify-declarations.js";
+/** One declared rate's latency reading from the CLAP qualifier (CLAP spec §3, latency). */
+export interface ClapLatencyAtRate {
+    /** `latency.get()` after `activate` at this rate; a plugin without the ext declares 0. */
+    readonly declaredFrames: number;
+    /** Where the qualifier's impulse landed through `process()`, in frames. */
+    readonly measuredFrames: number;
+}
+/**
+ * What the CLAP prober (`native/clap-qualify`) MEASURED about a CLAP plugin, RAW (CLAP spec §3): the facts the CLAP
+ * arm of each dimension reads. Whether any of it earns `suitable` is the `clap*Reasons` arms' to say.
+ */
+export interface PluginClapMeasurement {
+    /** Main audio ports: channel counts of the ONE main input and ONE main output the qualifier
+     *  found (0 where none); `sidechainInputs` counts non-main audio inputs. */
+    readonly mainInputChannels: number;
+    readonly mainOutputChannels: number;
+    readonly sidechainInputs: number;
+    /** `clap_plugin_descriptor.features`, as declared. */
+    readonly features: readonly string[];
+    /** `init()` and `activate()` both succeeded HEADLESS, with only OMX_CLAP_HOST_EXTENSIONS offered. */
+    readonly headlessOk: boolean;
+    /** Note input ports the `note-ports` ext declares (0 where the ext is absent). */
+    readonly noteInputs: number;
+    /** Declared vs measured latency at every declared rate, keyed by the rate's decimal string. */
+    readonly latency: Readonly<Record<string, ClapLatencyAtRate>>;
+    /** Strict `thread-check` violations counted across the sweep. */
+    readonly threadViolations: number;
+    /** `CLAP_PROCESS_ERROR` returns counted across the sweep. */
+    readonly processErrors: number;
+    /** `process()` calls the sweep made after its warm-up; a sweep of 0 measured nothing. */
+    readonly processCalls: number;
+}
+/** What the classifier is told about the console asking. */
+export interface HostingClassifyOptions {
+    /** The LIVE rate. Cost is read here and nowhere else — never projected. */
+    readonly rate: number;
+    /** The LIVE quantum in frames, when the console pins one. */
+    readonly quantum?: number;
+    /** Basename of the plugin's own binary, when known: a sanitizer error faulting there is the plugin's. */
+    readonly pluginBinary?: string;
+    readonly policy?: HostingPolicy;
+    /** Curator override. `isolated` is the ONLY legal value; see {@link assertHostingOverride}. */
+    readonly override?: "isolated";
+    /** The host the console is actually running, to compare against the figures' provenance. */
+    readonly consoleHost?: string;
+    /** False when the sweep's positive control did not fire — poisons the whole verdict. */
+    readonly sweepControlFired?: boolean;
+    /** The host judged against (plugin-qualify §3a). Absent: `openmixer-console`, the console's own. */
+    readonly profile?: HostProfile;
+}
+/** The verdict, and everything that produced it. */
+export interface PluginHosting {
+    readonly rating: SuitabilityRating;
+    readonly path: HostingPath;
+    readonly reasons: readonly HostingReason[];
+    /** The ONE reason that decided it: the worst, first-listed. Undefined when suitable. */
+    readonly deciding?: HostingReason;
+}
+/**
+ * Refuse an illegal override at the door. A curator may take a plugin OFF the RT thread and
+ * may never put one on it — no measurement, no in-process, and no "force" exists anywhere.
+ * Throws rather than coercing, because silently demoting a bad value would hide the mistake.
+ */
+export declare function assertHostingOverride(value: unknown, where: string): "isolated" | undefined;
+/**
+ * The level at which a rate is DEAD against the plugin's own best: `policy.soakDeadDropDb` or
+ * more below it. A ratio against the plugin itself, never an absolute floor — a quiet plugin is
+ * not a dead one. The one application of that threshold; the soak rule below and the report's
+ * short-render column both ask it.
+ */
+export declare function deadAgainstBest(levelDbfs: number, bestDbfs: number, policy: HostingPolicy): boolean;
+/** A soak's reading: what voided it, if anything, and what it proved when nothing did. */
+export interface SoakFindings {
+    /** The SHORTEST rate's seconds — a soak proves no more than its weakest rate ran. */
+    readonly seconds: number;
+    /** Every rate that voids the soak, as `<why>@<rate>` — `died@`, `non-finite@`, `dead@`, `mostly-silent@`, `startup-blast@`. */
+    readonly failures: readonly string[];
+    readonly ratesTested: number;
+    /** The largest RSS growth across rates, for the record; not judged. */
+    readonly rssGrowthKb: number;
+}
+/**
+ * Read a soak, rate by rate. A rate voids it if the plugin did not instantiate or died there,
+ * emitted a non-finite window, settled dead against its own best rate ({@link deadAgainstBest};
+ * settled = the LAST window, never the first — Calf opens at +200 dBFS at 192 k), spent more
+ * than half its windows silent, or opened above +6 dBFS. A few silent windows in ten thousand is
+ * a gate closing on a swept threshold — the plugin working, not dying.
+ *
+ * `undefined` when there is no soak, or it covered no rate: nothing was read.
+ */
+export declare function soakFindings(soak: SoakReading | undefined, policy: HostingPolicy): SoakFindings | undefined;
+/** Threads the plugin's first instance brought with it. */
+export declare function threadsSpawned(threads: ThreadReading | undefined): number;
+export declare function stabilityReasons(m: PluginStabilityMeasurement | undefined, policy: HostingPolicy, pluginBinary?: string, 
+/** Whether the plugin shares its process with others (profile isolation, §3a): threads it
+ *  spawns and a GUI toolkit it links are cautions only there. */
+sharesProcess?: boolean): readonly HostingReason[];
+/**
+ * Whether an interposer count is a MEASUREMENT: the interposer was loaded, all three counts are
+ * present, and the controls were swept — or the plugin has none a sweep could move, so its
+ * at-rest count is the only state there is. Measured at rest otherwise is not measured.
+ */
+export declare function rtSafetyMeasured(m: PluginRtSafetyMeasurement | undefined): boolean;
+/** A measured count above zero — the disqualifier, asked in one place. */
+export declare function rtSafetyViolating(m: PluginRtSafetyMeasurement | undefined): boolean;
+export declare function rtSafetyReasons(m: PluginRtSafetyMeasurement | undefined): readonly HostingReason[];
+export declare function featureReasons(features: PluginLv2Features | undefined, descriptor: Pick<QualifiedPlugin, "hasMidiIn">, provided?: readonly string[], quantumPinned?: boolean, 
+/** The host feeds MIDI input (an instrument host, §3a): a MIDI input is no caution there. */
+instruments?: boolean): readonly HostingReason[];
+export declare function hostingCostReasons(descriptor: Pick<QualifiedPlugin, "cpuCost">, options: HostingClassifyOptions, policy: HostingPolicy): readonly HostingReason[];
+export declare function hostingLatencyReasons(descriptor: Pick<QualifiedPlugin, "latency">, handling?: HostProfile["latency"]): readonly HostingReason[];
+export declare function hostingTopologyReasons(descriptor: Pick<QualifiedPlugin, "audioInputs" | "audioOutputs"> & Partial<Pick<QualifiedPlugin, "hasMidiIn">>, instruments?: boolean): readonly HostingReason[];
+/**
+ * The CLAP arm of `topology` (CLAP spec §3): the qualifier's main-port facts feed the same
+ * dimension the LV2 scan feeds. No measurement → `unknown` (`hosting.clap.unqualified`), never
+ * a guess from the descriptor.
+ */
+export declare function clapTopologyReasons(clap: PluginClapMeasurement | undefined, instruments?: boolean): readonly HostingReason[];
+/**
+ * The CLAP arm of `latency` (CLAP spec §3): declared = measured at EVERY declared rate earns;
+ * one rate that lies refuses (`unsuitable` — compensation reads the figure as truth); no rate
+ * measured is `unknown`.
+ */
+export declare function clapLatencyReasons(clap: PluginClapMeasurement | undefined): readonly HostingReason[];
+/**
+ * The CLAP arm of `features` (CLAP spec §3): an audio effect that initialised and activated
+ * HEADLESS with only OMX_CLAP_HOST_EXTENSIONS offered, and no note input (the measurement's or the
+ * scan's `hasMidiIn`). Every miss is its own code; a note input is an instrument, `unsuitable`.
+ */
+export declare function clapFeatureReasons(clap: PluginClapMeasurement | undefined, profile?: HostProfile, scannedNoteInput?: boolean): readonly HostingReason[];
+/**
+ * The CLAP additions to `rtSafety` (CLAP spec §3): the interposer's counts are read by
+ * `rtSafetyReasons` exactly as for an LV2; these are the two violations only a CLAP can commit
+ * — a strict thread-check violation and a `CLAP_PROCESS_ERROR` — each `unsuitable`. A sweep
+ * that made no `process()` call measured nothing.
+ */
+export declare function clapRtReasons(clap: PluginClapMeasurement | undefined): readonly HostingReason[];
+/**
+ * The verdict. Worst-wins across every dimension, exactly as `classifyForRole` folds — with
+ * three gates that can poison the whole result before the fold is even read: a curator
+ * override, a sweep whose positive control did not fire, and figures taken on a different
+ * host than the console is running.
+ */
+export declare function classifyPluginHosting(descriptor: QualifiedPlugin, options: HostingClassifyOptions): PluginHosting;
+/** What a racked slot's host actually IS, and the ONE reason it is that. */
+export interface RealisedHosting {
+    readonly path: HostingPath;
+    /** The plugin's own rating, carried through — `unknown` where nothing could be judged. */
+    readonly rating: SuitabilityRating;
+    readonly reason: HostingCode;
+}
+/** What the CONSOLE brings to the question, beside the plugin's own verdict. */
+export interface HostingRealisation {
+    /** The operator's authored switch (`/console/plugins/hosting`). */
+    readonly inProcessEnabled: boolean;
+    /** Whether an in-process body exists to run a plugin in at all. */
+    readonly inProcessAvailable: boolean;
+    /**
+     * Whether the plugin is LINKED into the engine (its static-link registry): it needs no verdict
+     * to run in-process (`2026-09-26-clap-hosting-path.md` §7). Absent reads as not linked.
+     */
+    readonly linked?: boolean;
+}
+/**
+ * The REALISED host of one racked plugin — a different fact from the verdict, and kept in a
+ * different field for that reason.
+ *
+ * `classifyPluginHosting` answers what a plugin EARNED. This answers where it RUNS, which
+ * three things decide in order, each with its own reason so the operator reads the first one
+ * that applies rather than a fold:
+ *
+ * 1. the console's switch is off — nothing runs in-process, whatever it earned;
+ * 1a. the plugin is LINKED into the engine — it runs in-process wherever a body exists, with no
+ *    verdict to read;
+ * 2. nothing could be judged (no verdict: the console has observed no rate and quantum) or the
+ *    verdict is below `suitable` — the plugin's own deciding reason stands;
+ * 3. it earned in-process and there is no in-process body to run it in yet.
+ *
+ * Order matters and is the operator's, not the machine's: a console-wide fact is a better
+ * answer to "why is this plugin not on the fast path" than a per-plugin one, because it is the
+ * one the operator can act on.
+ */
+export declare function realisedHosting(verdict: PluginHosting | undefined, realisation: HostingRealisation): RealisedHosting;