@termix-ssh/plugin-sdk 1.0.0

package/dist/host/types/src/ui/lib/adaptive-polling.d.ts

@@ -0,0 +1,29 @@
+export interface AdaptivePollingPolicy {
+    minIntervalMs: number;
+    maxIntervalMs: number;
+    stablePollsPerStep?: number;
+    jitterRatio?: number;
+    /** Prevent expensive requests from consuming more than this share of time. */
+    maxRequestDutyCycle?: number;
+}
+export interface AdaptivePollingState {
+    stablePolls: number;
+    consecutiveFailures: number;
+    lastPollDurationMs?: number;
+}
+export type AdaptivePollResult = boolean | void;
+export declare function computeAdaptivePollDelay(policy: AdaptivePollingPolicy, state: AdaptivePollingState, random?: () => number): number;
+export declare function runAdaptivePolling(poll: () => AdaptivePollResult | Promise<AdaptivePollResult>, policy: AdaptivePollingPolicy, options?: {
+    enabled?: () => boolean;
+    visible?: () => boolean;
+    runImmediately?: boolean;
+    random?: () => number;
+    intervalMultiplier?: () => number;
+    onError?: (error: unknown) => void;
+}): () => void;
+interface NetworkInformationLike {
+    saveData?: boolean;
+    effectiveType?: string;
+}
+export declare function getPollingEnvironmentMultiplier(connection?: NetworkInformationLike): number;
+export {};

package/dist/host/types/src/ui/lib/adaptive-resource-budget.d.ts

@@ -0,0 +1,39 @@
+export type AdaptiveTaskKind = "module" | "network";
+export type AdaptiveResourceTier = "paused" | "constrained" | "balanced" | "eager";
+export interface AdaptiveResourceEnvironment {
+    visible: boolean;
+    saveData?: boolean;
+    effectiveType?: string;
+    deviceMemoryGb?: number;
+    hardwareConcurrency?: number;
+}
+export interface AdaptiveResourceFeedback {
+    observations: number;
+    successes: number;
+    cancellations: number;
+    fallbacks: number;
+    latencyEwmaMs?: number;
+    usefulnessObservations?: number;
+    usefulPreloads?: number;
+}
+export interface AdaptiveResourceBudget {
+    tier: AdaptiveResourceTier;
+    allowModulePreload: boolean;
+    allowNetworkPrefetch: boolean;
+    maxPrefetchBytes: number;
+    maxConcurrentModulePreloads: number;
+    maxConcurrentNetworkPrefetches: number;
+    reason: "hidden" | "environment" | "feedback" | "default";
+}
+/** Marks that foreground navigation consumed a recent speculative preload. */
+export declare function markAdaptiveResourceUsed(kind: AdaptiveTaskKind, action: string, now?: number): void;
+/** Drops in-flight bookkeeping. Intended for tests and hard session resets. */
+export declare function resetAdaptiveResourceState(): void;
+export declare function computeAdaptiveResourceBudget(environment: AdaptiveResourceEnvironment, feedback?: AdaptiveResourceFeedback): AdaptiveResourceBudget;
+export declare function getAdaptiveResourceBudget(kind: AdaptiveTaskKind): AdaptiveResourceBudget;
+interface AdaptiveTaskOptions {
+    estimatedBytes?: number;
+}
+/** Starts optional work only when it fits the current local resource budget. */
+export declare function runAdaptiveBackgroundTask(kind: AdaptiveTaskKind, action: string, task: () => Promise<unknown>, options?: AdaptiveTaskOptions): boolean;
+export {};

package/dist/host/types/src/ui/lib/app-keyboard-shortcuts.d.ts

@@ -0,0 +1,8 @@
+export declare function isShiftKey(event: Pick<KeyboardEvent, "key" | "code">): boolean;
+export declare function getAltDigitShortcut(event: Pick<KeyboardEvent, "key" | "code">): number;
+export declare function dispatchCtrlW(target: EventTarget | null): boolean;
+/** Match two consecutive Shift presses, never a typing or IME sequence. */
+export declare function createCommandPaletteShortcutMatcher(): {
+    matches: (event: KeyboardEvent, now?: number) => boolean;
+    reset: () => void;
+};

package/dist/host/types/src/ui/lib/base-path.d.ts

@@ -0,0 +1 @@
+export declare function getBasePath(): string;

package/dist/host/types/src/ui/lib/clipboard-provider.d.ts

@@ -0,0 +1,9 @@
+import type { IClipboardProvider, ClipboardSelectionType } from "@xterm/addon-clipboard";
+export declare class RobustClipboardProvider implements IClipboardProvider {
+    private pendingWrite;
+    private readonly focusHandler;
+    constructor();
+    dispose(): void;
+    readText(_selection: ClipboardSelectionType): string | Promise<string>;
+    writeText(_selection: ClipboardSelectionType, text: string): Promise<void>;
+}

package/dist/host/types/src/ui/lib/clipboard.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Copies text to the clipboard, working around environments where the async
+ * Clipboard API is unavailable - notably Brave and any non-HTTPS origin, where
+ * `navigator.clipboard` is undefined. Tries the Electron bridge first, then the
+ * async Clipboard API, then a hidden-textarea execCommand fallback.
+ *
+ * Returns true on success so callers can decide whether to show a success or
+ * error toast.
+ */
+export declare function copyToClipboard(text: string): Promise<boolean>;
+/**
+ * Reads text from the clipboard, working around environments where the async
+ * Clipboard API is unavailable - notably any non-HTTPS origin, where
+ * `navigator.clipboard.readText` is undefined. Tries the Electron bridge
+ * first, then the async Clipboard API, then a hidden-textarea execCommand
+ * fallback (which still works over plain HTTP in Chromium-based browsers).
+ *
+ * Returns an empty string if every approach fails.
+ */
+export declare function readFromClipboard(): Promise<string>;

package/dist/host/types/src/ui/lib/connection-origin.d.ts

@@ -0,0 +1,47 @@
+export type ConnectionOrigin = "local" | "remote";
+interface OriginResolvableHost {
+    connectionOrigin?: ConnectionOrigin | null;
+}
+/**
+ * Resolves which backend a given host's interactive connection (SSH, Docker
+ * console, remote desktop) should dial: the desktop app's embedded local
+ * backend, or the server it is linked to. A plugin whose connection is
+ * always local regardless of this setting (serial: the hardware is
+ * physically attached to this desktop machine) skips this helper entirely
+ * and calls app.wsUrl() without an origin option, which defaults to "local".
+ *
+ * Everything else follows the host's own override if set, falling back to
+ * the desktop-wide default.
+ *
+ * `defaultRemote` makes a host left on Default resolve to "remote" instead of
+ * following the desktop-wide setting. Remote desktop passes it: it needs a
+ * guacd, which the desktop does not ship, so originating it here only works
+ * once the user has pointed Termix at one of their own. Making that opt-in
+ * per host keeps an upgrade from moving working connections onto a guacd
+ * that isn't there -- see Termix-SSH/Support#1240.
+ */
+export declare function resolveConnectionOrigin(host: OriginResolvableHost, options?: {
+    defaultRemote?: boolean;
+}): Promise<ConnectionOrigin>;
+export interface RemoteConnectionTarget {
+    serverUrl: string;
+    jwt: string | null;
+}
+/**
+ * Builds the base WebSocket URL for an interactive connection protocol,
+ * given a resolved origin. Returns null when origin is "remote" but this
+ * desktop is not linked to a server -- callers must show a blocking message
+ * rather than attempting to connect.
+ */
+export interface WebSocketConnectionTarget {
+    url: string;
+    protocols: string[];
+}
+export declare function buildOriginWsUrl({ origin, localPort, localPath, remotePath, includeJwt, }: {
+    origin: ConnectionOrigin;
+    localPort: number;
+    localPath: string;
+    remotePath: string;
+    includeJwt?: boolean;
+}): Promise<WebSocketConnectionTarget | null>;
+export {};

package/dist/host/types/src/ui/lib/db-health-monitor.d.ts

@@ -0,0 +1,34 @@
+/**
+ * DatabaseHealthMonitor
+ *
+ * Non-blocking health tracker for backend/database connectivity. The
+ * monitor no longer gates the whole UI: there is no full-screen overlay.
+ * When a transient failure is observed we emit a "degraded" event so the
+ * UI can surface a persistent but non-intrusive toast. A success from any
+ * API request clears the state. Session-expired events are also relayed
+ * to the UI.
+ *
+ * The previous "database-connection-lost" / "database-connection-restored"
+ * events have been retired along with the overlay. Listeners should use
+ * "database-connection-degraded" / "database-connection-degraded-cleared"
+ * to reflect the current UX contract: users can keep working regardless
+ * of backend hiccups and are simply informed via a toast.
+ */
+type EventListener = (...args: unknown[]) => void;
+declare class DatabaseHealthMonitor {
+    private static instance;
+    private listeners;
+    private degradedActive;
+    private constructor();
+    static getInstance(): DatabaseHealthMonitor;
+    on(event: string, listener: EventListener): void;
+    off(event: string, listener: EventListener): void;
+    private emit;
+    reportSessionExpired(): void;
+    reportDatabaseError(error: unknown): void;
+    reportDatabaseSuccess(): void;
+    isDegraded(): boolean;
+    reset(): void;
+}
+export declare const dbHealthMonitor: DatabaseHealthMonitor;
+export {};

package/dist/host/types/src/ui/lib/device-id.d.ts

@@ -0,0 +1 @@
+export declare function getDeviceId(): string | null;

package/dist/host/types/src/ui/lib/electron.d.ts

@@ -0,0 +1 @@
+export declare function isElectron(): boolean;

package/dist/host/types/src/ui/lib/embedded-server-status.d.ts

@@ -0,0 +1,15 @@
+export type EmbeddedServerFailureReason = "port-in-use" | "crashed";
+export interface EmbeddedServerFailure {
+    reason: EmbeddedServerFailureReason;
+    port: number | null;
+}
+/**
+ * Asks the Electron main process whether the embedded backend has failed for
+ * good.
+ *
+ * Returns null in every case where waiting is still the right thing to do:
+ * outside Electron, while the backend is only slow to boot, and on a desktop
+ * build old enough not to expose the channel at all. A non-null result means
+ * the backend process is gone and no amount of retrying will bring it back.
+ */
+export declare function getEmbeddedServerFailure(): Promise<EmbeddedServerFailure | null>;

package/dist/host/types/src/ui/lib/error-message.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Extract a stable, human-readable message from an unknown thrown value.
+ *
+ * A thrown value is not guaranteed to be an `Error` — libraries may throw
+ * strings or plain objects, which carry no useful `.message`. When that
+ * happens the caller gets `fallback` instead, so error paths never surface a
+ * raw `[object Object]` in logs or UI.
+ */
+export declare function getErrorMessage(error: unknown, fallback?: string): string;

package/dist/host/types/src/ui/lib/frontend-logger.d.ts

@@ -0,0 +1,67 @@
+export type LogLevel = "debug" | "info" | "warn" | "error" | "success";
+export interface LogContext {
+    operation?: string;
+    userId?: string;
+    hostId?: number;
+    sessionId?: string;
+    requestId?: string;
+    duration?: number;
+    method?: string;
+    url?: string;
+    status?: number;
+    statusText?: string;
+    responseTime?: number;
+    retryCount?: number;
+    errorCode?: string;
+    errorMessage?: string;
+    [key: string]: unknown;
+}
+declare class FrontendLogger {
+    private serviceName;
+    private serviceIcon;
+    private serviceColor;
+    private isDevelopment;
+    constructor(serviceName: string, serviceIcon: string, serviceColor: string);
+    private getTimeStamp;
+    private formatMessage;
+    private getLevelTag;
+    private getServiceTag;
+    private shouldLog;
+    private log;
+    debug(message: string, context?: LogContext): void;
+    info(message: string, context?: LogContext): void;
+    warn(message: string, context?: LogContext): void;
+    error(message: string, error?: unknown, context?: LogContext): void;
+    success(message: string, context?: LogContext): void;
+    api(message: string, context?: LogContext): void;
+    request(message: string, context?: LogContext): void;
+    response(message: string, context?: LogContext): void;
+    auth(message: string, context?: LogContext): void;
+    ssh(message: string, context?: LogContext): void;
+    file(message: string, context?: LogContext): void;
+    connection(message: string, context?: LogContext): void;
+    disconnect(message: string, context?: LogContext): void;
+    retry(message: string, context?: LogContext): void;
+    performance(message: string, context?: LogContext): void;
+    security(message: string, context?: LogContext): void;
+    requestStart(method: string, url: string, context?: LogContext): void;
+    requestSuccess(method: string, url: string, status: number, responseTime: number, context?: LogContext): void;
+    requestError(method: string, url: string, status: number, errorMessage: string, responseTime?: number, context?: LogContext): void;
+    networkError(method: string, url: string, errorMessage: string, context?: LogContext): void;
+    authError(method: string, url: string, context?: LogContext): void;
+    retryAttempt(method: string, url: string, attempt: number, maxAttempts: number, context?: LogContext): void;
+    apiOperation(operation: string, details: string, context?: LogContext): void;
+    requestSummary(method: string, url: string, status: number, responseTime: number, context?: LogContext): void;
+    private getShortUrl;
+    private getStatusIcon;
+    private getPerformanceIcon;
+    private sanitizeUrl;
+}
+export declare const apiLogger: FrontendLogger;
+export declare const authLogger: FrontendLogger;
+export declare const sshLogger: FrontendLogger;
+export declare const fileLogger: FrontendLogger;
+export declare const dashboardLogger: FrontendLogger;
+/** A named console logger, for plugins that want the same log format. */
+export declare function createFrontendLogger(serviceName: string, serviceIcon?: string, serviceColor?: string): FrontendLogger;
+export {};

package/dist/host/types/src/ui/lib/global-shortcut-handler.d.ts

@@ -0,0 +1,3 @@
+export declare const globalShortcutHandler: {
+    current: ((e: KeyboardEvent) => void) | null;
+};

package/dist/host/types/src/ui/lib/host-defaults-context.d.ts

@@ -0,0 +1,48 @@
+/**
+ * The host editor's view of host defaults, for the fields it draws.
+ *
+ * In a host, a field either follows its default (and says where from) or is
+ * the host's own (and can be reset). In the defaults editor, a field is either
+ * set at the level being edited (and can be cleared) or shows what it
+ * inherits. Outside either editor there is no provider and nothing renders.
+ */
+import type { HostDefaultSource, HostDefaultsLevel } from "../../types/host-defaults";
+export interface HostDefaultsContextValue {
+    mode: "host" | "defaults";
+    /** The level being edited, in the defaults editor. */
+    level?: HostDefaultsLevel;
+    /** A host's own value, or a value set at the level being edited. */
+    isOwn: (fullKey: string) => boolean;
+    /** Where the value it would otherwise have comes from. */
+    source: (fullKey: string) => HostDefaultSource | undefined;
+    /** Follows the default again, or clears the value at this level. */
+    reset: (fullKey: string) => void;
+    /** Whether the key can have a default here at all. */
+    isAvailable: (fullKey: string) => boolean;
+}
+export declare const HostDefaultsContext: import("react").Context<HostDefaultsContextValue>;
+export declare function useHostDefaults(): HostDefaultsContextValue | null;
+/** Whether the editor is editing a level of defaults rather than a host. */
+export declare function useIsDefaultsEditor(): boolean;
+/**
+ * A short key ("fontSize") is the calling plugin's own; core passes a full
+ * one ("core.sshPort").
+ */
+export declare function useDefaultKey(settingKey: string | undefined): string | null;
+export declare function useSourceLabel(): (source: HostDefaultSource | undefined) => string;
+/**
+ * The marker next to a field's label: where an inherited value comes from,
+ * or a control to hand an own value back.
+ */
+export declare function HostDefaultBadge({ settingKey }: {
+    settingKey: string;
+}): import("react").JSX.Element;
+/** Renders its children only when the key can have a default in this editor. */
+export declare function DefaultsOnly({ settingKey, children, }: {
+    settingKey: string;
+    children: React.ReactNode;
+}): import("react").JSX.Element;
+/** Renders its children only when editing a host, never a level of defaults. */
+export declare function HostOnly({ children }: {
+    children: React.ReactNode;
+}): import("react").JSX.Element;

package/dist/host/types/src/ui/lib/hosts-request-cache.d.ts

@@ -0,0 +1,9 @@
+import type { SSHHost, SSHFolder } from "../../types/index";
+import type { ServerStatus } from "../main-axios";
+export declare function getCachedSSHHosts(loader: () => Promise<SSHHost[]>): Promise<SSHHost[]>;
+export declare function getCachedServerStatuses(loader: () => Promise<Record<number, ServerStatus>>): Promise<Record<number, ServerStatus>>;
+export declare function invalidateServerStatusCache(): void;
+export declare function getCachedSSHFolders(loader: () => Promise<SSHFolder[]>): Promise<SSHFolder[]>;
+export declare function invalidateSSHFoldersCache(): void;
+/** Drop all caches after host mutations so the next read is fresh. */
+export declare function invalidateHostsAndStatusCaches(): void;

package/dist/host/types/src/ui/lib/keybinding-match.d.ts

@@ -0,0 +1,3 @@
+import type { CustomKeybinding, KeyCombo } from "../../types/keybindings";
+export declare function eventMatchesCombo(e: KeyboardEvent, combo: KeyCombo): boolean;
+export declare function findMatchingKeybinding(e: KeyboardEvent, bindings: CustomKeybinding[]): CustomKeybinding | undefined;

package/dist/host/types/src/ui/lib/linked-server.d.ts

@@ -0,0 +1,10 @@
+import { SYNC_CHANGED_EVENT } from "./sync-events";
+export { SYNC_CHANGED_EVENT };
+/** The server this desktop is linked to, and the session it syncs with. */
+export interface LinkedSession {
+    serverUrl: string;
+    token: string;
+}
+/** Null on the web, or when this desktop is not linked or signed out. */
+export declare function getLinkedSession(): Promise<LinkedSession | null>;
+export declare function notifySyncChanged(): void;

package/dist/host/types/src/ui/lib/local-adaptive-engine.d.ts

@@ -0,0 +1,40 @@
+export declare const LOCAL_ADAPTIVE_ENGINE_KEY = "termix.local.adaptive-engine.v1";
+export interface LocalAdaptiveOutcome {
+    success?: boolean;
+    latencyMs?: number;
+    cancelled?: boolean;
+    fallback?: boolean;
+}
+export interface LocalAdaptiveActionStats {
+    weight: number;
+    updatedAt: number;
+    observations: number;
+    successes: number;
+    cancellations: number;
+    fallbacks: number;
+    latencyEwmaMs?: number;
+}
+export interface LocalAdaptiveDecision<T extends string> {
+    action: T;
+    confidence: number;
+    reason: "fallback" | "insufficient-evidence" | "learned";
+    expiresAt: number;
+}
+interface DecisionOptions<T extends string> {
+    scope: string;
+    candidates: readonly T[];
+    fallback: T;
+    now?: number;
+    ttlMs?: number;
+    minEvidence?: number;
+    minShare?: number;
+    minMargin?: number;
+}
+/** Records an abstract user choice. Never pass raw paths, input, or content. */
+export declare function recordLocalAdaptiveChoice(scope: string, action: string, now?: number): void;
+/** Records performance separately so failed actions are not reinforced. */
+export declare function recordLocalAdaptiveOutcome(scope: string, action: string, outcome: LocalAdaptiveOutcome, now?: number): void;
+export declare function chooseLocalAdaptiveAction<T extends string>({ scope, candidates, fallback, now, ttlMs, minEvidence, minShare, minMargin, }: DecisionOptions<T>): LocalAdaptiveDecision<T>;
+export declare function getLocalAdaptiveStats(scope: string): Readonly<Record<string, LocalAdaptiveActionStats>>;
+export declare function clearLocalAdaptiveEngine(): void;
+export {};

package/dist/host/types/src/ui/lib/permissions.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Frontend copy of the permission matching rules.
+ *
+ * This mirrors PermissionManager.hasPermission in
+ * src/backend/utils/permission-manager.ts and has to stay in step with it. It
+ * is a second implementation of one rule, which is a real cost, accepted here
+ * only because this copy is cosmetic: it decides what UI to show, never what
+ * a request is allowed to do. The server checks again on every route.
+ */
+/**
+ * Whether a granted permission set covers the one required.
+ *
+ * Order matches the backend: the "*" superuser grant, an exact match, then
+ * progressively shorter dotted wildcards, then admin last.
+ */
+export declare function matchesPermission(granted: readonly string[], isAdmin: boolean, required: string): boolean;

package/dist/host/types/src/ui/lib/plugin-i18n.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Where a plugin's i18n keys resolve from.
+ *
+ * A manifest writes plugin-relative keys ("permissions.devices.view.title") so
+ * it never has to know where the strings live. They live in the plugin's own
+ * locales/en.json, loaded into an i18next namespace named after the plugin,
+ * so the qualified key is "<pluginId>:<key>". A key that already names a
+ * namespace is left alone. Missing keys fall back to core strings.
+ */
+export declare function pluginKey(pluginId: string, key: string): string;
+export declare function pluginKey(pluginId: string, key: string | undefined): string | undefined;

package/dist/host/types/src/ui/lib/plugin-icon.d.ts

@@ -0,0 +1,11 @@
+import { type LucideProps } from "lucide-react";
+/**
+ * A manifest names its icon as a Lucide component name ("Sparkles").
+ *
+ * An unknown or missing name falls back to a generic plugin glyph rather than
+ * rendering nothing, so a plugin shipping a typo still gets a row an admin can
+ * read.
+ */
+export declare function PluginIcon({ name, ...props }: {
+    name?: string;
+} & LucideProps): import("react").JSX.Element;

package/dist/host/types/src/ui/lib/plugin-transport.d.ts

@@ -0,0 +1,50 @@
+/**
+ * How a plugin frontend reaches its own backend.
+ *
+ * Every plugin serves HTTP under /plugin-api/<id>/ and WebSockets under
+ * /plugin-ws/<id>/<path> on the main backend. No plugin has a port of its own,
+ * so these two helpers are all a plugin frontend needs, in every deployment:
+ *
+ *   - web, same origin, optionally under a base path;
+ *   - Docker behind nginx, which proxies both prefixes;
+ *   - the Vite dev server, which proxies through /__termix_api/30001;
+ *   - Electron with its embedded local backend;
+ *   - Electron pointed at a remote Termix server, for hosts whose connection
+ *     origin resolves there.
+ *
+ * A7 re-exports both through @termix-ssh/plugin-sdk/frontend. They live here for
+ * now because plugin frontends are still bundled with the shell.
+ */
+import type { AxiosInstance } from "axios";
+import { type ConnectionOrigin, type WebSocketConnectionTarget } from "./connection-origin";
+/**
+ * An axios client rooted at this plugin's /plugin-api mount point.
+ *
+ * Built on the shared authenticated instance, so a plugin inherits the same
+ * interceptors as core: auth headers, session expiry handling and error
+ * reporting all behave identically.
+ */
+export declare function createPluginApi(pluginId: string): AxiosInstance;
+/**
+ * A raw fetch on this plugin's /plugin-api mount point, for a response the
+ * caller reads as a stream (server-sent events). axios buffers the whole
+ * body, so it cannot. Sends the same auth the shared client does.
+ */
+export declare function pluginFetch(pluginId: string, path: string, init?: RequestInit): Promise<Response>;
+/**
+ * The same client pointed at the connected remote server, for a desktop app
+ * host whose connection origin is "remote". Outside Electron, and for
+ * "local", it is the ordinary client.
+ */
+export declare function pluginApiFor(pluginId: string, origin: ConnectionOrigin | undefined, local: AxiosInstance): AxiosInstance;
+/**
+ * The WebSocket URL for /plugin-ws/<id>/<path>, plus the subprotocols that
+ * carry the JWT.
+ *
+ * In Electron the right backend depends on where the host actually lives, so
+ * pass the resolved origin; without one it targets the embedded local backend,
+ * which is what a plugin with no per-host notion of origin wants.
+ */
+export declare function pluginWsUrl(pluginId: string, path: string, options?: {
+    origin?: ConnectionOrigin;
+}): Promise<WebSocketConnectionTarget | null>;

package/dist/host/types/src/ui/lib/registry.d.ts

@@ -0,0 +1,29 @@
+/**
+ * A keyed, reactive list of contributions.
+ *
+ * Plugins register and unregister at runtime, so anything the shell renders
+ * from a registry has to re-render when it changes. The snapshot array is
+ * cached until the next change because useSyncExternalStore compares by
+ * identity and loops forever on a fresh array.
+ */
+export interface Registry<T extends {
+    id: string;
+}> {
+    /** Adds or replaces by id. The disposer only removes this exact entry. */
+    register: (item: T) => () => void;
+    unregister: (id: string) => void;
+    get: (id: string) => T | undefined;
+    list: () => T[];
+    subscribe: (listener: () => void) => () => void;
+    /** React hook over list(). */
+    useList: () => T[];
+    reset: () => void;
+}
+export declare function createRegistry<T extends {
+    id: string;
+}>(sort?: (a: T, b: T) => number): Registry<T>;
+/** Orders by `order`, then id, so plugin contributions sort stably. */
+export declare function byOrderThenId<T extends {
+    id: string;
+    order?: number;
+}>(a: T, b: T): number;

package/dist/host/types/src/ui/lib/rem.d.ts

@@ -0,0 +1,7 @@
+/**
+ * A length in px at the Normal interface size, as rem, so it follows the
+ * interface size setting like Tailwind classes do.
+ */
+export declare function rem(px: number): string;
+/** How many real pixels one Normal-size pixel takes right now. */
+export declare function remScale(): number;

package/dist/host/types/src/ui/lib/remote-server-api.d.ts

@@ -0,0 +1,11 @@
+import type { AxiosInstance } from "axios";
+/**
+ * Hosts shared with a linked account arrive through sync as read-only local
+ * copies that already carry the auth the owner shared, so a connection needs
+ * nothing extra. Kept for plugins that still call it.
+ */
+export declare function hydrateLocalSharedHostAuth<T>(host: T): Promise<T>;
+/** The linked server's core API, or null when this desktop is not linked. */
+export declare function getConnectedRemoteApi(): Promise<AxiosInstance | null>;
+/** The linked server's own id for a host, found by its sync id. */
+export declare function resolveRemoteHostId(syncId: string | null | undefined): Promise<number | null>;

package/dist/host/types/src/ui/lib/server-status-store.d.ts

@@ -0,0 +1,37 @@
+export type StatusValue = "online" | "offline" | "unknown";
+export interface ServerStatusEntry {
+    status: "online" | "offline";
+    lastChecked: string;
+}
+type Listener = () => void;
+/**
+ * Mutable store for per-host status so list rows can subscribe to a single host
+ * via useSyncExternalStore instead of re-rendering the whole tree on every poll.
+ */
+export declare class ServerStatusStore {
+    private statuses;
+    private initialLoadComplete;
+    private readonly hostListeners;
+    private readonly allListeners;
+    private readonly metaListeners;
+    /** "unknown" until the host has been checked. */
+    getStatus(hostId: number): StatusValue;
+    getStatuses(): Map<number, ServerStatusEntry>;
+    getInitialLoadComplete(): boolean;
+    getMetaSnapshot(): string;
+    subscribeHost(hostId: number, listener: Listener): () => void;
+    subscribeAll(listener: Listener): () => void;
+    subscribeMeta(listener: Listener): () => void;
+    setInitialLoadComplete(complete: boolean): void;
+    /**
+     * Replace status map. Notifies only hosts whose status value changed,
+     * plus allListeners when any change occurred.
+     */
+    applyStatuses(next: Map<number, ServerStatusEntry>): void;
+    /** Forgets everything, on sign out. */
+    clear(): void;
+    private emitHost;
+    private emitAll;
+    private emitMeta;
+}
+export {};

package/dist/host/types/src/ui/lib/sync-events.d.ts

@@ -0,0 +1,2 @@
+/** Fired whenever the desktop's link or its synced data changed. */
+export declare const SYNC_CHANGED_EVENT = "termix:sync-changed";

package/dist/host/types/src/ui/lib/sync-status.d.ts

@@ -0,0 +1,6 @@
+import { type SyncStatus } from "../api/sync-api";
+export declare function subscribeSyncStatus(listener: () => void): () => void;
+export declare function getSyncStatusSnapshot(): SyncStatus | null;
+/** Takes a status a request already returned, and checks again soon. */
+export declare function setSyncStatus(next: SyncStatus): void;
+export declare function refreshSyncStatus(): void;

package/dist/host/types/src/ui/lib/tab-jump-hotkey.d.ts

@@ -0,0 +1,4 @@
+export declare function isMacPlatform(): boolean;
+export declare function isTabJumpHotkey(e: KeyboardEvent): boolean;
+export declare function getTabJumpDigit(e: KeyboardEvent): number | null;
+export declare function tabJumpHotkeyKeys(): string[];

package/dist/host/types/src/ui/lib/theme.d.ts

@@ -0,0 +1,21 @@
+import type { DashboardCardConfig, FontSizeId, UiFontId } from "../../types/ui-types";
+export declare const DASHBOARD_CARDS: DashboardCardConfig[];
+export declare const ACCENT_PRESET_COLORS: {
+    label: string;
+    value: string;
+}[];
+export declare function applyAccentColor(colorValue: string): void;
+export declare const FONT_SIZES: {
+    id: FontSizeId;
+    label: string;
+}[];
+/** The root font size of each interface size, relative to Normal. */
+export declare const FONT_SIZE_SCALE: Record<FontSizeId, number>;
+export declare function applyFontSize(id: FontSizeId): void;
+export declare const UI_FONTS: {
+    id: UiFontId;
+    label: string;
+    family: string;
+}[];
+export declare function applyUiFont(id: UiFontId): void;
+export declare const FOLDER_COLORS: string[];