/** * The in-memory registry the shell reads, plus {@link loadPlugin} — the one entry * through which a plugin bundle's `register(context)` contributes to it. This module * is bundled only into the served `@tai42/studio-sdk/host` singleton (external across * the plugin boundary, like react and react-dom), so the module-level registry is * the SAME instance every host caller — the shell and the feature panels — sees. The * plugin surface (`@tai42/studio-sdk`) does not include it, so a plugin cannot reach it. */ import type { PluginContributions, PluginEntry } from './types'; /** * What the host knows about a plugin from its registry listing entry: `mounts`, the * plugin's own route items and their resolved absolute bases (`{item: "/api/"}`), * and `declaredRoutePanels`, the channels its manifest lists under * `contributions.route_panels`. */ export interface PluginLoadInputs { readonly mounts: Readonly>; readonly declaredRoutePanels: readonly string[]; } /** * Load one plugin: call its `register` entry with a context bound to `pluginId`, * then commit everything it staged into the global registry. * * `entry` is AWAITED before commit, so a synchronous or an `async` entry is fully * done first: a post-`await` throw skips the commit (atomicity holds for async too) * and a post-`await` registration cannot slip past the batch. The seal is set after * `entry` has SETTLED, so a later registration throws loudly; registrations made * during `entry`'s synchronous body — including a microtask it enqueues then — are * still captured and committed. A `register` that throws commits nothing. */ export declare function loadPlugin(pluginId: string, entry: PluginEntry, host: PluginLoadInputs): Promise; /** The shell reads this after loading every installed plugin bundle. */ export declare function getContributions(): PluginContributions; /** Tests reset the module-level registry between cases. */ export declare function __resetContributions(): void; //# sourceMappingURL=registry.d.ts.map