/** A kernel that can host a controller candidate.
 *
 *  Telo is polyglot: one manifest is loaded by different kernels, and a given
 *  `controllers:` candidate is hostable by only some of them.
 *
 *  The labels are deliberately the ones the ecosystem already uses — the
 *  `runtime:` field on an `imports:` entry (`LABEL_TO_PURL_TYPE` in
 *  `kernel/nodejs/src/runtime-registry.ts`) and the implementation directory a
 *  contributor sees at `modules/<name>/<label>/`. Coining a third spelling for
 *  the same two kernels would mean an author who wrote `runtime: nodejs` had to
 *  learn that this filter wants something else. */
export type Runtime = "nodejs" | "rust";
/** The language a controller is written in, where the PURL actually determines
 *  it. A bundled `napi` / `wasm` artifact does not: a `.node` file may be Rust,
 *  C++ or Zig, so those contribute no language rather than a guess. */
export type Language = "javascript" | "rust";
export interface KindRuntimeSupport {
    /** Kernels that can load this kind. Empty when it is `portable`, and also when
     *  it declares controllers no kernel hosts — `portable` separates the two. */
    runtimes: Runtime[];
    languages: Language[];
    /** Declares no controllers at all, so no kernel constraint applies. Recorded
     *  as a flag rather than by enumerating today's kernels, which would make every
     *  stored row wrong the day a third kernel ships. */
    portable: boolean;
}
/** Classify one kind from its declared `controllers:` list. */
export declare function kindRuntimeSupport(controllers: readonly string[]): KindRuntimeSupport;
export interface KindRuntimeEntry extends KindRuntimeSupport {
    /** The kind suffix (`metadata.name`), the identity the hub rows key on. */
    name: string;
}
/** Per-kernel coverage across a module's kinds. A kernel that hosts none of them
 *  is absent rather than `"none"`, so the map lists only what actually runs. */
export type RuntimeCoverage = Partial<Record<Runtime, "full" | "partial">>;
export interface ModuleRuntimeReport {
    kinds: KindRuntimeEntry[];
    languages: Language[];
    runtimes: RuntimeCoverage;
    /** Every kind is portable — the module carries no controller code at all. */
    portable: boolean;
}
/** Roll per-kind support up to the module.
 *
 *  A boolean would lie: `std/console` ships Rust controllers for two of its four
 *  kinds, so it is Node-`full` and Rust-`partial`. Portable kinds count as
 *  supported everywhere, which is what keeps a "runs on rust" filter honest for
 *  a module that mixes portable and JS-only kinds. The rollup is recomputed on
 *  every re-ingest, so it self-heals when the kernel set changes. */
export declare function moduleRuntimeReport(kinds: KindRuntimeEntry[]): ModuleRuntimeReport;
//# sourceMappingURL=controller-runtime.d.ts.map