@artemis-studio/plugin-sdk 2026.9.37

package/types/kernel/auth/Can.d.ts

@@ -0,0 +1,9 @@
+import type { ReactNode } from 'react';
+export interface CanProps {
+    permission: string;
+    clusterId?: string;
+    children: ReactNode;
+    fallback?: ReactNode;
+}
+/** Renders `children` only if the current user holds `permission` (optionally scoped to `clusterId`). */
+export declare function Can({ permission, clusterId, children, fallback }: CanProps): import("react").JSX.Element;

package/types/kernel/auth/LoginView.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The login screen, built only from the installation's identity providers
+ * (identity-and-sessions spec): a username and password form when a credential
+ * provider exists — with a choice when there is more than one — and one sign-in
+ * action per redirect provider. While the list loads the form is offered, so a
+ * slow request never reads as "sign-in unavailable".
+ */
+export declare function LoginView(): import("react").JSX.Element;

package/types/kernel/auth/api.d.ts

@@ -0,0 +1,29 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import { ApiError } from "../api/request.ts";
+import type { components } from "../api/schema.d.ts";
+type Schemas = components["schemas"];
+export type GrantView = Schemas["GrantView"];
+export type IdentityProviderView = Schemas["IdentityProviderView"];
+export type LoginRequest = Schemas["LoginRequest"];
+export type MeView = Schemas["MeView"];
+export declare const keys: {
+    authProviders: readonly ["auth", "providers"];
+    me: readonly ["auth", "me"];
+};
+/** `retry: false` — a 401 here means "not logged in," which retrying cannot fix. */
+export declare function useMe(): UseQueryResult<MeView, ApiError>;
+/** Public, unauthenticated — the login screen needs this before any session exists. */
+export declare function useAuthProviders(): UseQueryResult<IdentityProviderView[], ApiError>;
+export declare function useLogin(): import("@tanstack/react-query").UseMutationResult<{
+    id: string;
+    username: string;
+    mustChangePassword: boolean;
+    grants: components["schemas"]["GrantView"][];
+    reauthentication: components["schemas"]["ReauthenticationView"];
+}, ApiError, {
+    provider?: string | null;
+    username: string;
+    password: string;
+}, unknown>;
+export declare function useLogout(): import("@tanstack/react-query").UseMutationResult<void, ApiError, void, unknown>;
+export {};

package/types/kernel/auth/useCan.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Client-side reflection of the server's permission model (authorization
+ * spec) — used only to hide/disable controls a request would be rejected for
+ * anyway. The server's `@PreAuthorize`/`ClusterAccessGuard` checks are the
+ * real enforcement; this never substitutes for them.
+ */
+export declare function useCan(): {
+    can: (permission: string, clusterId?: string) => boolean;
+    grants: {
+        scopeType: string;
+        scopeId?: string | null;
+        permissions: string[];
+    }[];
+    loading: boolean;
+};

package/types/kernel/feature.d.ts

@@ -0,0 +1,80 @@
+import type { ComponentType } from 'react';
+import type { SpotlightActionGroupData } from '@mantine/spotlight';
+import type { Icon } from '@tabler/icons-react';
+import type { AnyRoute } from '@tanstack/react-router';
+import type { NavGroupId } from './nav/groups.ts';
+import type { SlotContributions } from './slots.ts';
+/** The extension contract version, shared with the backend's `Contract.VERSION` (ADR-0070). */
+export declare const CONTRACT = 1;
+/** The module ids the backend manifest reports. A frontend feature uses the same id as its backend module. */
+export declare const FEATURE_IDS: readonly ["security", "audit", "settings", "stream", "broker", "clusters", "governance", "scrape", "mcp", "queues", "resources", "messages", "routing", "metrics", "alerting", "events", "rr", "sql", "brokerconfig", "flow", "triage", "bulk", "transfer", "setupreview", "apitokens", "plugins", "identity-local", "identity-oidc"];
+export type FeatureId = (typeof FEATURE_IDS)[number];
+/**
+ * An installed plugin's id, as its `plugin.json` declares it: lowercase kebab-case, vendor first,
+ * at least two segments (ADR-0099). A plugin's routes, slot ids and topics are all namespaced by it.
+ */
+export type PluginId = `${string}-${string}`;
+/** A built-in module or an installed plugin — whatever the manifest lists. */
+export type ModuleId = FeatureId | PluginId;
+/**
+ * The routes a feature adds, each created with a kernel root from `routing/roots.ts` as its parent. The
+ * composition root adds every installed feature's routes whether or not the feature is enabled, so a deep
+ * link to a disabled feature reaches the page that explains it rather than a not-found.
+ */
+export interface RouteContributions {
+    /** Pages outside any cluster, children of `rootRoute`. */
+    root?: AnyRoute[];
+    /** Views of one cluster, children of `clusterRoute`. */
+    cluster?: AnyRoute[];
+}
+/** One view in a cluster's navigation and command palette. */
+export interface NavContribution {
+    group: NavGroupId;
+    /** Position within the group; lower comes first. */
+    order: number;
+    label: string;
+    icon: Icon;
+    /** The view's path below `/clusters/$clusterId/`. */
+    path: string;
+    /**
+     * The permission the view reads with. Without it the entry stays visible and disabled,
+     * and says why; the server enforces it regardless.
+     */
+    permission?: string;
+    /** Shown after the label, such as a count of what needs attention. */
+    Badge?: ComponentType<{
+        clusterId: string;
+    }>;
+}
+/**
+ * A feature's command-palette groups. It is rendered inside the palette, so it may use hooks, and calls
+ * `report` whenever its groups change; `clusterId` is the cluster in view, if there is one.
+ */
+export type PaletteSource = ComponentType<{
+    clusterId?: string;
+    report: (groups: SpotlightActionGroupData[]) => void;
+}>;
+/** Handles one frame of a stream topic the feature owns (ADR-0070). */
+export type TopicHandler = (frame: {
+    clusterId: string;
+    /** The frame's payload, as the server sent it. */
+    data: string;
+    /** Invalidates a query key, or only marks it stale while refreshing is paused. */
+    invalidate: (queryKey: readonly unknown[]) => void;
+}) => void;
+/** What a frontend feature contributes to the shell (ADR-0070). */
+export interface StudioFeature {
+    contract: typeof CONTRACT;
+    /** A built-in's module id, or a plugin's id (a plugin is loaded from its own bundle at startup). */
+    id: ModuleId;
+    routes?: RouteContributions;
+    nav?: NavContribution[];
+    palette?: PaletteSource;
+    slots?: SlotContributions;
+    /**
+     * A handler per stream topic the feature's backend module declares. A cluster's layout subscribes to
+     * the topics of every enabled feature.
+     */
+    streamTopics?: Record<string, TopicHandler>;
+}
+export declare function defineFeature<T extends StudioFeature>(feature: T): T;

package/types/kernel/features.d.ts

@@ -0,0 +1,5 @@
+import type { StudioFeature } from './feature.ts';
+/** The composition root's features. The kernel never imports them; `FeatureProvider` hands them in (ADR-0069). */
+export declare const FeaturesContext: import("react").Context<StudioFeature[] | null>;
+/** The installed features this installation has enabled, in composition order. */
+export declare function useFeatures(): StudioFeature[];

package/types/kernel/manifest.d.ts

@@ -0,0 +1,21 @@
+import { type UseQueryResult } from '@tanstack/react-query';
+import { type ApiError } from './api/request.ts';
+import type { components } from './api/schema.d.ts';
+import type { ModuleId, StudioFeature } from './feature.ts';
+export type ManifestView = components['schemas']['ManifestView'];
+export type ManifestFeatureView = components['schemas']['ManifestFeatureView'];
+export declare const manifestKey: readonly ["manifest"];
+/**
+ * What this installation offers (feature-modules spec). It describes and never authorizes: every
+ * endpoint enforces its permission whatever a screen derived from this. Read once per page load:
+ * plugin bundles are loaded before the router exists, so a plugin change needs a reload anyway,
+ * and `usePluginsChanged` offers one when the server's `version` moves on.
+ */
+export declare function useManifest(): UseQueryResult<ManifestView, ApiError>;
+/** The manifest's entry for a module; undefined until the manifest has loaded. */
+export declare function useManifestFeature(id: ModuleId): ManifestFeatureView | undefined;
+/**
+ * The given features less those this installation has disabled. Until the manifest answers, every
+ * feature counts as enabled: hiding a view before then would state something nobody has checked.
+ */
+export declare function useEnabledFeatures(features: StudioFeature[]): StudioFeature[];

package/types/kernel/nav/groups.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The navigation groups, in the order the rail shows them (ADR-0070). The list is closed:
+ * a feature names one of these for each view it contributes, and adding a group is a
+ * kernel change, which keeps the rail coherent as features are added.
+ */
+export declare const NAV_GROUPS: readonly [{
+    readonly id: "observe";
+    readonly label: "Observe";
+}, {
+    readonly id: "messaging";
+    readonly label: "Messaging";
+}, {
+    readonly id: "resources";
+    readonly label: "Resources";
+}, {
+    readonly id: "configuration";
+    readonly label: "Configuration";
+}, {
+    readonly id: "activity";
+    readonly label: "Activity";
+}];
+export type NavGroupId = (typeof NAV_GROUPS)[number]['id'];

package/types/kernel/plugins/PluginBoundary.d.ts

@@ -0,0 +1,25 @@
+import { Component, type ErrorInfo, type ReactNode } from 'react';
+interface Props {
+    pluginId: string;
+    /** What to render instead: nothing for a badge or a palette source, a sentence for a panel. */
+    quiet?: boolean;
+    children: ReactNode;
+}
+/**
+ * Keeps a plugin's failure to itself (ADR-0100): a plugin component that throws while rendering
+ * is replaced by a sentence naming the plugin — or by nothing, where a sentence would not fit —
+ * and the screen around it keeps working.
+ */
+export declare class PluginBoundary extends Component<Props, {
+    failed: boolean;
+}> {
+    state: {
+        failed: boolean;
+    };
+    static getDerivedStateFromError(): {
+        failed: boolean;
+    };
+    componentDidCatch(error: unknown, info: ErrorInfo): void;
+    render(): string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | import("react").JSX.Element | null | undefined;
+}
+export {};

package/types/kernel/plugins/PluginUnavailable.d.ts

@@ -0,0 +1,6 @@
+/**
+ * What an address under `/p/<id>/` shows when no plugin page answers it (ADR-0100): whether the
+ * plugin is installed at all, and if so the state that keeps its page away — never a blank page
+ * or a bare not-found. Administrators are pointed at the plugin's row.
+ */
+export declare function PluginUnavailable(): import("react").JSX.Element;

package/types/kernel/plugins/boot.d.ts

@@ -0,0 +1,29 @@
+import { type StudioFeature } from '../feature.ts';
+import type { ManifestFeatureView, ManifestView } from '../manifest.ts';
+/** How long the shell waits for the manifest, and for each plugin bundle, before going on without it. */
+export declare const MANIFEST_TIMEOUT_MS = 5000;
+export declare const REMOTE_TIMEOUT_MS = 10000;
+/** What the page learned while starting: the manifest (when it could be read) and every plugin that did not load. */
+export interface Boot {
+    manifest?: ManifestView;
+    /** Why the manifest could not be read; the built-in screens load regardless. */
+    manifestError?: string;
+    plugins: StudioFeature[];
+    /** Plugin id → why its screens are not here. */
+    failures: Map<string, string>;
+}
+export declare function bootState(): Boot;
+/** For tests. */
+export declare function setBootState(boot: Boot): void;
+/** The Module Federation container name a plugin's bundle is built with: its id, in snake_case. */
+export declare function remoteName(id: string): string;
+type Federation = Pick<typeof import('@module-federation/runtime'), 'registerRemotes' | 'loadRemote'>;
+/**
+ * Loads every active plugin's bundle, each bounded by {@link REMOTE_TIMEOUT_MS}, and keeps the
+ * ones that pass {@link checkPlugin}. A bundle that fails, is slow or breaks the rules is left
+ * out with its reason; nothing a plugin does here can keep Studio's own screens from loading.
+ */
+export declare function loadPlugins(entries: ManifestFeatureView[], federation?: () => Promise<Federation>): Promise<Pick<Boot, 'plugins' | 'failures'>>;
+/** Everything the page needs before it builds its router: the manifest, then the plugins it names. */
+export declare function boot(): Promise<Boot>;
+export {};

package/types/kernel/plugins/guarded.d.ts

@@ -0,0 +1,3 @@
+import type { ComponentType } from 'react';
+/** `Inner` inside a {@link PluginBoundary}, with the same props. */
+export declare function guarded<P extends object>(pluginId: string, Inner: ComponentType<P>, quiet?: boolean): ComponentType<P>;

package/types/kernel/plugins/usePluginsChanged.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Offers a reload once the server's plugins differ from the ones this page started with (ADR-0100):
+ * checked when the window regains focus and every minute. It never reloads on its own — the
+ * operator may be halfway through something — and says so once, until they act.
+ */
+export declare function usePluginsChanged(onChange?: () => void): void;

package/types/kernel/plugins/validate.d.ts

@@ -0,0 +1,19 @@
+import { type StudioFeature } from '../feature.ts';
+import type { ManifestFeatureView } from '../manifest.ts';
+/** A loaded plugin module, accepted and made safe to mount, or the reason it was not. */
+export type Checked = {
+    ok: true;
+    feature: StudioFeature;
+} | {
+    ok: false;
+    reason: string;
+};
+/** The first segment a plugin route's path must have: everything it adds lives under `p/<id>/`. */
+export declare function pluginPathPrefix(id: string): string;
+/**
+ * Accepts what a plugin's bundle exported only when it keeps to its own namespace (ADR-0100):
+ * the contract it was built for, its own id, routes and navigation under `p/<id>/`, slot entries
+ * named `<id>.…`, only the stream topics its descriptor declared, and navigation groups the shell
+ * has. Every component it contributes to a shared screen is wrapped so a throw stays its own.
+ */
+export declare function checkPlugin(entry: ManifestFeatureView, exported: unknown): Checked;

package/types/kernel/registry.d.ts

@@ -0,0 +1,12 @@
+import type { NavContribution, StudioFeature } from './feature.ts';
+import { type NavGroupId } from './nav/groups.ts';
+export interface NavGroup {
+    id: NavGroupId;
+    label: string;
+    items: NavContribution[];
+}
+/**
+ * The features' views under the kernel's groups (ADR-0070): groups in their fixed order, views in
+ * their declared order, and a group none of the features contributes to left out.
+ */
+export declare function navGroups(features: StudioFeature[]): NavGroup[];

package/types/kernel/routing/roots.d.ts

@@ -0,0 +1,15 @@
+import { type ComponentType, type ReactElement } from 'react';
+import type { ModuleId } from '../feature.ts';
+/** The root every page renders inside: the shell. A feature's `routes.root` are its children. */
+export declare const rootRoute: import("@tanstack/react-router").RootRoute<import("@tanstack/router-core").Register, undefined, {}, import("@tanstack/router-core").AnyContext, import("@tanstack/router-core").AnyContext, {}, undefined, unknown, unknown, unknown, unknown, undefined>;
+/** One cluster's layout. A feature's `routes.cluster` are its children. */
+export declare const clusterRoute: import("@tanstack/react-router").Route<unknown, import("@tanstack/react-router").RootRoute<import("@tanstack/router-core").Register, undefined, {}, import("@tanstack/router-core").AnyContext, import("@tanstack/router-core").AnyContext, {}, undefined, unknown, unknown, unknown, unknown, undefined>, "clusters/$clusterId", "/clusters/$clusterId", string, "/clusters/$clusterId", undefined, import("@tanstack/router-core").ResolveParams<"clusters/$clusterId">, import("@tanstack/router-core").AnyContext, import("@tanstack/router-core").AnyContext, import("@tanstack/router-core").AnyContext, {}, undefined, unknown, unknown, unknown, unknown, undefined>;
+export declare const pluginClusterFallback: import("@tanstack/react-router").Route<unknown, import("@tanstack/react-router").Route<unknown, import("@tanstack/react-router").RootRoute<import("@tanstack/router-core").Register, undefined, {}, import("@tanstack/router-core").AnyContext, import("@tanstack/router-core").AnyContext, {}, undefined, unknown, unknown, unknown, unknown, undefined>, "clusters/$clusterId", "/clusters/$clusterId", string, "/clusters/$clusterId", undefined, import("@tanstack/router-core").ResolveParams<"clusters/$clusterId">, import("@tanstack/router-core").AnyContext, import("@tanstack/router-core").AnyContext, import("@tanstack/router-core").AnyContext, {}, undefined, unknown, unknown, unknown, unknown, undefined>, "p/$pluginId/$", "/clusters/$clusterId/p/$pluginId/$", string, "/clusters/$clusterId/p/$pluginId/$", undefined, import("@tanstack/router-core").ResolveParams<"p/$pluginId/$">, import("@tanstack/router-core").AnyContext, import("@tanstack/router-core").AnyContext, import("@tanstack/router-core").AnyContext, {}, undefined, unknown, unknown, unknown, unknown, undefined>;
+/** The shell's own pages, beside the cluster layout. */
+export declare const shellRoutes: (import("@tanstack/react-router").Route<unknown, import("@tanstack/react-router").RootRoute<import("@tanstack/router-core").Register, undefined, {}, import("@tanstack/router-core").AnyContext, import("@tanstack/router-core").AnyContext, {}, undefined, unknown, unknown, unknown, unknown, undefined>, "/", "/", string, "/", undefined, import("@tanstack/router-core").ResolveParams<"/">, import("@tanstack/router-core").AnyContext, import("@tanstack/router-core").AnyContext, import("@tanstack/router-core").AnyContext, {}, undefined, unknown, unknown, unknown, unknown, undefined> | import("@tanstack/react-router").Route<unknown, import("@tanstack/react-router").RootRoute<import("@tanstack/router-core").Register, undefined, {}, import("@tanstack/router-core").AnyContext, import("@tanstack/router-core").AnyContext, {}, undefined, unknown, unknown, unknown, unknown, undefined>, "login", "/login", string, "/login", undefined, import("@tanstack/router-core").ResolveParams<"login">, import("@tanstack/router-core").AnyContext, import("@tanstack/router-core").AnyContext, import("@tanstack/router-core").AnyContext, {}, undefined, unknown, unknown, unknown, unknown, undefined> | import("@tanstack/react-router").Route<unknown, import("@tanstack/react-router").RootRoute<import("@tanstack/router-core").Register, undefined, {}, import("@tanstack/router-core").AnyContext, import("@tanstack/router-core").AnyContext, {}, undefined, unknown, unknown, unknown, unknown, undefined>, "admin", "/admin", string, "/admin", (raw: Record<string, unknown>) => {
+    tab?: string;
+    plugin?: string;
+    upload?: string;
+}, import("@tanstack/router-core").ResolveParams<"admin">, import("@tanstack/router-core").AnyContext, import("@tanstack/router-core").AnyContext, import("@tanstack/router-core").AnyContext, {}, undefined, unknown, unknown, unknown, unknown, undefined> | import("@tanstack/react-router").Route<unknown, import("@tanstack/react-router").RootRoute<import("@tanstack/router-core").Register, undefined, {}, import("@tanstack/router-core").AnyContext, import("@tanstack/router-core").AnyContext, {}, undefined, unknown, unknown, unknown, unknown, undefined>, "account", "/account", string, "/account", undefined, import("@tanstack/router-core").ResolveParams<"account">, import("@tanstack/router-core").AnyContext, import("@tanstack/router-core").AnyContext, import("@tanstack/router-core").AnyContext, {}, undefined, unknown, unknown, unknown, unknown, undefined> | import("@tanstack/react-router").Route<unknown, import("@tanstack/react-router").RootRoute<import("@tanstack/router-core").Register, undefined, {}, import("@tanstack/router-core").AnyContext, import("@tanstack/router-core").AnyContext, {}, undefined, unknown, unknown, unknown, unknown, undefined>, "p/$pluginId/$", "/p/$pluginId/$", string, "/p/$pluginId/$", undefined, import("@tanstack/router-core").ResolveParams<"p/$pluginId/$">, import("@tanstack/router-core").AnyContext, import("@tanstack/router-core").AnyContext, import("@tanstack/router-core").AnyContext, {}, undefined, unknown, unknown, unknown, unknown, undefined>)[];
+/** A feature's view, or the page explaining that the feature is disabled on this installation (feature-modules spec). */
+export declare function featureView(feature: ModuleId, View: ComponentType): () => ReactElement;

package/types/kernel/shell/AccountView.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The signed-in user's own page: who you are, then what the features contribute — how to change
+ * your password, the keys you hold, and how to connect an assistant with one.
+ *
+ * <p>API keys used to live under Administration, which made a per-user
+ * credential look like an operator's tool and hid it from everyone without
+ * {@code user:admin}. Every user has an account, so this route is ungated.
+ */
+export declare function AccountView(): import("react").JSX.Element;

package/types/kernel/shell/AdminView.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Studio-wide administration (authorization spec): one tab per contribution, such as users, roles,
+ * environments and identity provider group mappings. The open tab is in the URL.
+ */
+export declare function AdminView(): import("react").JSX.Element;

package/types/kernel/shell/ClusterLayout.d.ts

@@ -0,0 +1,10 @@
+/**
+ * One cluster's screen: the header its features contribute, then the routed view.
+ *
+ * It mounts the cluster's one SSE stream, subscribed to the topics of every enabled feature
+ * (ADR-0018, ADR-0070). A view never opens a second one for a topic a feature handles: a second
+ * `EventSource` is a second connection, and it fights over the shared stream-status store. The
+ * stream reconnects indefinitely and reports its state to the header's freshness indicator
+ * (ADR-0052); while it is down the per-hook refetch intervals keep every view updating.
+ */
+export declare function ClusterLayout(): import("react").JSX.Element;

package/types/kernel/shell/ClusterViewNav.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The per-cluster view nav (ADR-0034), grouped (ADR-0070). Each enabled feature contributes its
+ * views to one of the kernel's groups; a group with no enabled view is not shown. Expanded, a group
+ * has a visible heading; collapsed, a divider, and its heading stays available to a screen reader.
+ * A view the operator lacks the read permission for stays listed and disabled, with the reason:
+ * a missing entry would read as a product that cannot do it. Only rendered while a cluster is the
+ * active route.
+ */
+export declare function ClusterViewNav({ clusterId, collapsed }: {
+    clusterId: string;
+    collapsed: boolean;
+}): import("react").JSX.Element;

package/types/kernel/shell/CommandPalette.d.ts

@@ -0,0 +1,10 @@
+/**
+ * ⌘K navigation across the console: jump to a view, or to whatever the features contribute — a
+ * cluster, a queue by name. Mounted once in the root layout; the shortcut is registered by
+ * {@link Spotlight}.
+ *
+ * Refresh and pause live here rather than on a hotkey: the browser owns both
+ * shortcuts an operator would reach for (⌘R and ⇧⌘R), and taking either would be
+ * worse than not having one (ADR-0052).
+ */
+export declare function CommandPalette(): import("react").JSX.Element;

package/types/kernel/shell/FeatureDisabled.d.ts

@@ -0,0 +1,13 @@
+/**
+ * What a disabled feature's address shows (feature-modules spec): that the feature is off on this
+ * installation rather than missing or broken, the startup property that turns it on, and the way
+ * back. Never a blank page or a not-found, which would teach the operator the view does not exist.
+ */
+export declare function FeatureDisabled({ title, property, clusterId, }: {
+    /** The feature's title, as the manifest names it. */
+    title: string;
+    /** The startup property that enables it, as the manifest names it. */
+    property: string;
+    /** The cluster the address belongs to, when it is a cluster view. */
+    clusterId?: string;
+}): import("react").JSX.Element;

package/types/kernel/shell/FeatureGate.d.ts

@@ -0,0 +1,12 @@
+import type { ReactNode } from 'react';
+import type { ModuleId } from '../feature.ts';
+/**
+ * A feature's view, or the page that explains the feature is disabled on this installation
+ * (feature-modules spec). It waits for the manifest rather than rendering a disabled view whose
+ * every request would fail as not found. If the manifest cannot be read the view renders: the
+ * server still refuses a disabled feature's calls, so nothing is exposed by trying.
+ */
+export declare function FeatureGate({ feature, children }: {
+    feature: ModuleId;
+    children: ReactNode;
+}): import("react").JSX.Element;

package/types/kernel/shell/FreshnessBar.d.ts

@@ -0,0 +1,11 @@
+export type FreshnessState = 'live' | 'polling' | 'reconnecting' | 'offline' | 'paused';
+/**
+ * The one place that answers "is this current?" — in the header, on every route
+ * (ADR-0052).
+ *
+ * Stream health and data health are separate states. A cluster whose stream is
+ * down but whose queries are succeeding is `Polling`, not `Offline`; conflating
+ * them would cry wolf on every proxy hiccup. A route that mounts no stream is
+ * `Polling` too, which is the literal truth there.
+ */
+export declare function FreshnessBar(): import("react").JSX.Element;

package/types/kernel/shell/HomeView.d.ts

@@ -0,0 +1,5 @@
+/**
+ * The landing page, with no cluster open: what the features contribute for it. The clusters feature
+ * sends the operator to the first cluster, or teaches how to register one.
+ */
+export declare function HomeView(): import("react").JSX.Element;

package/types/kernel/shell/NavItem.d.ts

@@ -0,0 +1,22 @@
+import { type ReactNode } from 'react';
+/**
+ * One sidebar row, shared by the cluster switcher and the per-cluster view nav
+ * (ADR-0034). Collapsed state hides the label visually but never from a screen
+ * reader — `aria-label` carries it, and the `Tooltip` supplies the mouse
+ * equivalent, opened late enough (350ms) that sweeping the rail doesn't flicker
+ * a tooltip per row.
+ *
+ * A row with a `disabledReason` is not a link. It stays in the tab order, so the
+ * reason is reachable by keyboard: the tooltip opens on focus as well as hover,
+ * and a screen reader hears the reason as the row's description.
+ */
+export declare function NavItem({ to, label, leading, trailing, collapsed, disabledReason, }: {
+    to: string;
+    label: string;
+    /** An icon, a health mark, or a monogram — whatever leads the row. */
+    leading: ReactNode;
+    trailing?: ReactNode;
+    collapsed: boolean;
+    /** Why the row cannot be opened; the row is disabled while this is set. */
+    disabledReason?: string;
+}): import("react").JSX.Element;

package/types/kernel/shell/NavToggle.d.ts

@@ -0,0 +1,6 @@
+/** A real button — `aria-expanded`/`aria-controls` so the collapse is announced. */
+export declare function NavToggle({ collapsed, onToggle, controls, }: {
+    collapsed: boolean;
+    onToggle: () => void;
+    controls: string;
+}): import("react").JSX.Element;

package/types/kernel/shell/RootLayout.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The desktop workspace chrome: a fixed header, the collapsible sidebar (the features' way between
+ * clusters, then the open cluster's view nav, ADR-0034), and the routed detail column.
+ * Desktop-first — no mobile breakpoint (`breakpoint: 0`).
+ *
+ * The sidebar collapses to a 64px icon rail rather than disappearing: `AppShell`'s
+ * own `collapsed` prop removes the navbar's width entirely, which is the wrong
+ * shape for a rail that stays present with icons. Animating `navbar.width`
+ * instead lets `AppShell` transition both the navbar and the `Main` offset in
+ * lockstep under one `transitionDuration` (design.md Decision 7).
+ */
+export declare function RootLayout(): import("react").JSX.Element | null;

package/types/kernel/shell/UserMenu.d.ts

@@ -0,0 +1,6 @@
+import { type MeView } from '../auth/api.ts';
+export interface UserMenuProps {
+    me: MeView | undefined;
+}
+/** The signed-in user's identity, admin entry point, account page, and logout (identity-and-sessions spec). */
+export declare function UserMenu({ me }: UserMenuProps): import("react").JSX.Element | null;

package/types/kernel/shell/useFreshness.d.ts

@@ -0,0 +1,25 @@
+/** What the header can say about the data on the screen right now (ADR-0052). */
+export interface Freshness {
+    /** Newest successful fetch among the queries this screen is observing, in epoch ms. */
+    lastUpdatedAt: number | null;
+    isFetching: boolean;
+    /** At least one query the screen depends on is in error. */
+    hasError: boolean;
+    /** How many queries the screen is observing. Zero means there is nothing to report. */
+    observed: number;
+}
+/**
+ * Freshness derived from the query cache rather than wired per screen.
+ *
+ * The queries with **active observers** are exactly the ones the screen on the
+ * display depends on, so no screen can forget to opt in and a screen added later
+ * is covered the day it is written. A query nobody is watching has no freshness
+ * worth reporting.
+ *
+ * `lastUpdatedAt` is the *newest* success, not the oldest: the oldest is
+ * pessimistic in a misleading way — one slow background query would make a live
+ * screen read as stale — and the honesty lives in `hasError` instead, which puts
+ * the whole indicator into its offline state rather than letting a fresh sibling
+ * paper over a failing one.
+ */
+export declare function useFreshness(): Freshness;

package/types/kernel/shell/useNavCollapsed.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Sidebar collapse state, persisted per browser (ADR-0034). A boolean local to
+ * one component doesn't need a global store (non-negotiable #9) — `localStorage`
+ * is the whole state layer. `getInitialValueInEffect: false` reads synchronously
+ * so there is no expand→collapse flash on first paint.
+ */
+export declare function useNavCollapsed(): {
+    collapsed: boolean;
+    toggle: () => void;
+};