@termix-ssh/plugin-sdk 1.0.20 → 1.0.22

package/dist/host/chunk-I5F2PSMR.js

@@ -0,0 +1,1526 @@
+const __termixNoGlob = () => ({});
+import {
+  arrangeCompanions,
+  companionApplies,
+  companionKey,
+  getPanel,
+  getSettingsComponent,
+  hostToSSHHost,
+  invokeAction,
+  patchCompanionState,
+  resolveCompanionLayout,
+  useActionSlot,
+  useCompanionDefs,
+  useCompanionLayoutDefs,
+  useCompanionState,
+  useIsMobile,
+  useSettingsComponents
+} from "./chunk-HQ6NNFSX.js";
+import {
+  usePermissions
+} from "./chunk-JRV2HIDK.js";
+import {
+  Button,
+  DefaultsOnly,
+  FakeSwitch,
+  HostDefaultBadge,
+  Input,
+  PluginIcon,
+  SectionCard,
+  SettingRow,
+  hasVisibleFields,
+  isFieldShown
+} from "./chunk-7J4QNGFM.js";
+import {
+  ArrowDownToLine,
+  ArrowLeftToLine,
+  ArrowRightToLine,
+  Check,
+  Checkbox,
+  CheckboxIndicator,
+  CircleSlash,
+  DocsLink,
+  Eye,
+  EyeOff,
+  LayoutPanelLeft,
+  OPEN_PLUGINS_EVENT,
+  PLUGINS_CHANGED_EVENT,
+  PanelRight,
+  Puzzle,
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+  Server,
+  Settings,
+  X,
+  cn,
+  getPlugins,
+  isRedactedSecret,
+  pluginKey,
+  pluginName,
+  usePluginScope
+} from "./chunk-VKNGNEF3.js";
+import {
+  getTabType,
+  unregisteredViewStatus,
+  usePluginStore
+} from "./chunk-P26QKKU5.js";
+import {
+  init_define_import_meta_env
+} from "./chunk-YGYBM7SQ.js";
+
+// src/ui/components/checkbox.tsx
+init_define_import_meta_env();
+import { jsx } from "react/jsx-runtime";
+function Checkbox2({
+  className,
+  ...props
+}) {
+  return /* @__PURE__ */ jsx(
+    Checkbox,
+    {
+      "data-slot": "checkbox",
+      className: cn(
+        "peer border-input dark:bg-input/30 data-[state=checked]:bg-primary data-[state=checked]:text-primary-foreground dark:data-[state=checked]:bg-primary data-[state=checked]:border-primary focus-visible:border-ring focus-visible:ring-ring/50 aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive size-4 shrink-0 rounded-none border shadow-xs transition-shadow outline-none focus-visible:ring-[3px] disabled:cursor-not-allowed disabled:opacity-50",
+        className
+      ),
+      ...props,
+      children: /* @__PURE__ */ jsx(
+        CheckboxIndicator,
+        {
+          "data-slot": "checkbox-indicator",
+          className: "flex items-center justify-center text-current transition-none",
+          children: /* @__PURE__ */ jsx(Check, { className: "size-3.5" })
+        }
+      )
+    }
+  );
+}
+
+// src/ui/components/password-input.tsx
+init_define_import_meta_env();
+import * as React from "react";
+import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+var PasswordInput = React.forwardRef(({ className, ...props }, ref) => {
+  const [showPassword, setShowPassword] = React.useState(false);
+  return /* @__PURE__ */ jsxs("div", { className: "relative w-full", children: [
+    /* @__PURE__ */ jsx2(
+      Input,
+      {
+        ref,
+        type: showPassword ? "text" : "password",
+        className: cn("h-11 text-base pr-12", className),
+        ...props
+      }
+    ),
+    /* @__PURE__ */ jsx2(
+      "button",
+      {
+        type: "button",
+        onClick: () => setShowPassword((prev) => !prev),
+        className: "absolute right-3 top-1/2 -translate-y-1/2 text-muted-foreground hover:text-foreground transition",
+        "aria-label": showPassword ? "Hide password" : "Show password",
+        children: showPassword ? /* @__PURE__ */ jsx2(EyeOff, { className: "h-5 w-5" }) : /* @__PURE__ */ jsx2(Eye, { className: "h-5 w-5" })
+      }
+    )
+  ] });
+});
+PasswordInput.displayName = "PasswordInput";
+
+// src/ui/components/textarea.tsx
+init_define_import_meta_env();
+import * as React2 from "react";
+import { jsx as jsx3 } from "react/jsx-runtime";
+var Textarea = React2.forwardRef(
+  ({ className, ...props }, ref) => {
+    return /* @__PURE__ */ jsx3(
+      "textarea",
+      {
+        className: cn(
+          "flex min-h-[80px] w-full rounded-none border border-input bg-transparent dark:bg-input/30 px-3 py-2 text-sm shadow-xs transition-[color,box-shadow] duration-200 outline-none placeholder:text-muted-foreground focus-visible:border-ring focus-visible:ring-ring/50 focus-visible:ring-[3px] disabled:cursor-not-allowed disabled:opacity-50 disabled:pointer-events-none",
+          className
+        ),
+        ref,
+        ...props
+      }
+    );
+  }
+);
+Textarea.displayName = "Textarea";
+
+// src/ui/hooks/use-installed-plugins.ts
+init_define_import_meta_env();
+import { useEffect, useState as useState2 } from "react";
+function useInstalledPlugins() {
+  const [plugins, setPlugins] = useState2([]);
+  useEffect(() => {
+    let cancelled = false;
+    let request = 0;
+    const load = () => {
+      const current = ++request;
+      void getPlugins().then((loaded) => {
+        if (!cancelled && current === request) setPlugins(loaded);
+      }).catch(() => {
+      });
+    };
+    load();
+    window.addEventListener(PLUGINS_CHANGED_EVENT, load);
+    return () => {
+      cancelled = true;
+      window.removeEventListener(PLUGINS_CHANGED_EVENT, load);
+    };
+  }, []);
+  return plugins;
+}
+
+// src/ui/settings/SettingsFields.tsx
+init_define_import_meta_env();
+import { useTranslation } from "react-i18next";
+import { Fragment, jsx as jsx4, jsxs as jsxs2 } from "react/jsx-runtime";
+function SettingsFieldRow({
+  pluginId,
+  field,
+  values,
+  setValue,
+  running,
+  error,
+  disabled = false,
+  defaultKey
+}) {
+  const { t } = useTranslation();
+  useSettingsComponents();
+  const label = (key) => key ? t(pluginKey(pluginId, key)) : "";
+  if (field.type === "custom") {
+    const Component = getSettingsComponent(pluginId, field.component);
+    if (!Component) return null;
+    return /* @__PURE__ */ jsx4(
+      Component,
+      {
+        pluginId,
+        values,
+        setValue,
+        running
+      }
+    );
+  }
+  const value = values[field.key];
+  const readOnly = disabled || !running;
+  const description = field.descriptionKey ? /* @__PURE__ */ jsxs2(Fragment, { children: [
+    label(field.descriptionKey),
+    error && /* @__PURE__ */ jsx4("span", { className: "block text-destructive mt-0.5", children: error })
+  ] }) : error ? /* @__PURE__ */ jsx4("span", { className: "text-destructive", children: error }) : void 0;
+  const control = /* @__PURE__ */ jsx4(
+    FieldControl,
+    {
+      pluginId,
+      field,
+      value,
+      setValue,
+      readOnly
+    }
+  );
+  if (field.type === "boolean") {
+    return /* @__PURE__ */ jsx4(
+      SettingRow,
+      {
+        label: label(field.labelKey),
+        description,
+        badge: error ? t("common.error") : void 0,
+        defaultKey,
+        children: control
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx4(DefaultsOnly, { settingKey: defaultKey ?? "", children: /* @__PURE__ */ jsxs2("div", { className: "flex flex-col gap-1.5 py-3 border-b border-border last:border-0 min-w-0", children: [
+    /* @__PURE__ */ jsxs2("div", { className: "flex items-center gap-1.5 flex-wrap", children: [
+      /* @__PURE__ */ jsx4("span", { className: "text-sm font-medium leading-snug", children: label(field.labelKey) }),
+      error && /* @__PURE__ */ jsx4("span", { className: "text-[10px] font-bold text-warning border border-warning/40 px-1 shrink-0", children: t("common.error") }),
+      defaultKey && /* @__PURE__ */ jsx4(HostDefaultBadge, { settingKey: defaultKey })
+    ] }),
+    description && /* @__PURE__ */ jsx4("span", { className: "text-xs text-muted-foreground leading-snug", children: description }),
+    /* @__PURE__ */ jsx4("div", { className: "min-w-0", children: control })
+  ] }) });
+}
+function FieldControl({
+  pluginId,
+  field,
+  value,
+  setValue,
+  readOnly
+}) {
+  const { t } = useTranslation();
+  const label = (key) => key ? t(pluginKey(pluginId, key)) : "";
+  const placeholder = field.placeholderKey ? label(field.placeholderKey) : void 0;
+  switch (field.type) {
+    case "boolean":
+      return /* @__PURE__ */ jsx4(
+        FakeSwitch,
+        {
+          checked: value === true,
+          disabled: readOnly,
+          onChange: (next) => setValue(field.key, next)
+        }
+      );
+    case "number":
+      return /* @__PURE__ */ jsx4(
+        Input,
+        {
+          type: "number",
+          className: "h-8 w-full max-w-40 text-sm",
+          disabled: readOnly,
+          min: field.min,
+          max: field.max,
+          placeholder,
+          value: value === void 0 || value === null ? "" : String(value),
+          onChange: (event) => setValue(
+            field.key,
+            event.target.value === "" ? null : Number(event.target.value)
+          )
+        }
+      );
+    case "select":
+      return /* @__PURE__ */ jsxs2(
+        Select,
+        {
+          disabled: readOnly,
+          value: typeof value === "string" ? value : "",
+          onValueChange: (next) => setValue(field.key, next),
+          children: [
+            /* @__PURE__ */ jsx4(SelectTrigger, { className: "h-8 w-full min-w-0 text-sm", children: /* @__PURE__ */ jsx4(SelectValue, { placeholder }) }),
+            /* @__PURE__ */ jsx4(SelectContent, { children: (field.options ?? []).map((option) => /* @__PURE__ */ jsx4(SelectItem, { value: option.value, children: label(option.labelKey) }, option.value)) })
+          ]
+        }
+      );
+    case "multiselect": {
+      const selected = Array.isArray(value) ? value : [];
+      return /* @__PURE__ */ jsx4("div", { className: "flex flex-col gap-1.5", children: (field.options ?? []).map((option) => /* @__PURE__ */ jsxs2(
+        "label",
+        {
+          className: "flex items-center gap-2 text-xs text-muted-foreground",
+          children: [
+            /* @__PURE__ */ jsx4(
+              Checkbox2,
+              {
+                disabled: readOnly,
+                checked: selected.includes(option.value),
+                onCheckedChange: (checked) => setValue(
+                  field.key,
+                  checked ? [...selected, option.value] : selected.filter((entry) => entry !== option.value)
+                )
+              }
+            ),
+            /* @__PURE__ */ jsx4("span", { children: label(option.labelKey) })
+          ]
+        },
+        option.value
+      )) });
+    }
+    case "secret":
+      return /* @__PURE__ */ jsx4(
+        SecretControl,
+        {
+          field,
+          value,
+          setValue,
+          readOnly,
+          placeholder
+        }
+      );
+    case "textarea":
+    case "json":
+      return /* @__PURE__ */ jsx4(
+        Textarea,
+        {
+          className: "w-full text-sm font-mono min-h-16",
+          disabled: readOnly,
+          placeholder,
+          value: typeof value === "string" ? value : value === void 0 || value === null ? "" : JSON.stringify(value, null, 2),
+          onChange: (event) => setValue(field.key, event.target.value)
+        }
+      );
+    default:
+      return /* @__PURE__ */ jsx4(
+        Input,
+        {
+          className: "h-8 w-full text-sm",
+          disabled: readOnly,
+          placeholder,
+          value: typeof value === "string" ? value : "",
+          onChange: (event) => setValue(field.key, event.target.value)
+        }
+      );
+  }
+}
+function SecretControl({
+  field,
+  value,
+  setValue,
+  readOnly,
+  placeholder
+}) {
+  const { t } = useTranslation();
+  const redacted = isRedactedSecret(value);
+  const stored = redacted && value.set;
+  if (redacted) {
+    return /* @__PURE__ */ jsxs2("div", { className: "flex flex-wrap items-center gap-2", children: [
+      /* @__PURE__ */ jsx4("span", { className: "text-xs text-muted-foreground", children: stored ? t("settings.secretSet") : t("settings.secretNotSet") }),
+      /* @__PURE__ */ jsx4(
+        Button,
+        {
+          variant: "outline",
+          size: "sm",
+          className: "h-7 text-xs",
+          disabled: readOnly,
+          onClick: () => setValue(field.key, ""),
+          children: stored ? t("settings.secretReplace") : t("common.edit")
+        }
+      )
+    ] });
+  }
+  return /* @__PURE__ */ jsxs2("div", { className: "flex items-center gap-2 min-w-0", children: [
+    /* @__PURE__ */ jsx4("div", { className: "min-w-0 flex-1", children: /* @__PURE__ */ jsx4(
+      PasswordInput,
+      {
+        className: "h-8 w-full text-sm",
+        disabled: readOnly,
+        placeholder,
+        value: typeof value === "string" ? value : "",
+        onChange: (event) => setValue(field.key, event.target.value)
+      }
+    ) }),
+    /* @__PURE__ */ jsx4(
+      Button,
+      {
+        variant: "ghost",
+        size: "sm",
+        className: "h-7 text-xs",
+        disabled: readOnly,
+        onClick: () => setValue(field.key, { set: stored }),
+        children: t("common.cancel")
+      }
+    )
+  ] });
+}
+
+// src/ui/settings/HostPluginSections.tsx
+init_define_import_meta_env();
+import { useMemo } from "react";
+import { useTranslation as useTranslation2 } from "react-i18next";
+import { jsx as jsx5, jsxs as jsxs3 } from "react/jsx-runtime";
+function usePluginHostSections() {
+  const plugins = useInstalledPlugins();
+  return useMemo(
+    () => plugins.filter((plugin) => {
+      if (!plugin.enabled) return false;
+      const host = plugin.contributes?.settings?.host;
+      return !!host && (hasVisibleFields(host.fields) || !!host.enableKey);
+    }),
+    [plugins]
+  );
+}
+function hostFieldDefaults(plugin) {
+  const host = plugin.contributes?.settings?.host;
+  if (!host) return {};
+  const defaults = {};
+  if (host.enableKey) defaults[host.enableKey] = host.enableDefault ?? false;
+  for (const field of host.fields) {
+    if (field.default !== void 0) defaults[field.key] = field.default;
+  }
+  return defaults;
+}
+function HostPluginSections({
+  plugins,
+  values,
+  setValue
+}) {
+  if (plugins.length === 0) return null;
+  return /* @__PURE__ */ jsx5("div", { className: "flex flex-col gap-2", children: plugins.map((plugin) => /* @__PURE__ */ jsx5(
+    HostPluginSection,
+    {
+      plugin,
+      values: values[plugin.id] ?? {},
+      setValue: (key, value) => setValue(plugin.id, key, value)
+    },
+    plugin.id
+  )) });
+}
+function HostFeatureFields({
+  form,
+  updateForm
+}) {
+  const pluginId = usePluginScope();
+  const plugin = usePluginHostSections().find((p) => p.id === pluginId);
+  if (!plugin) return null;
+  const values = form?.pluginSettings ?? {};
+  return /* @__PURE__ */ jsx5(
+    HostPluginSection,
+    {
+      plugin,
+      values: values[plugin.id] ?? {},
+      setValue: (key, value) => updateForm((current) => {
+        const all = current.pluginSettings ?? {};
+        return {
+          ...current,
+          pluginSettings: {
+            ...all,
+            [plugin.id]: { ...all[plugin.id] ?? {}, [key]: value }
+          }
+        };
+      })
+    }
+  );
+}
+function HostPluginSection({
+  plugin,
+  values,
+  setValue
+}) {
+  const { t } = useTranslation2();
+  const host = plugin.contributes?.settings?.host;
+  if (!host) return null;
+  const shown = { ...hostFieldDefaults(plugin), ...values };
+  const running = plugin.enabled && plugin.state !== "failed";
+  const enableKey = host.enableKey;
+  const enabled = enableKey ? shown[enableKey] === true : true;
+  return /* @__PURE__ */ jsxs3(
+    SectionCard,
+    {
+      title: pluginName(t, plugin),
+      icon: /* @__PURE__ */ jsx5(PluginIcon, { name: plugin.icon, className: "size-3.5" }),
+      action: /* @__PURE__ */ jsx5(DocsLink, { href: plugin.docs }),
+      children: [
+        !running && /* @__PURE__ */ jsx5("div", { className: "my-3 border border-warning/40 bg-warning/10 px-3 py-2 text-xs text-warning", children: t("settings.featureUnavailable", {
+          name: pluginName(t, plugin)
+        }) }),
+        enableKey && /* @__PURE__ */ jsx5(
+          SettingsFieldRow,
+          {
+            pluginId: plugin.id,
+            field: {
+              key: enableKey,
+              type: "boolean",
+              labelKey: host.enableLabelKey,
+              descriptionKey: host.enableDescriptionKey
+            },
+            values: shown,
+            setValue,
+            running,
+            defaultKey: `${plugin.id}.${enableKey}`
+          }
+        ),
+        enabled && host.fields.filter((field) => isFieldShown(field, shown)).map((field) => /* @__PURE__ */ jsx5(
+          SettingsFieldRow,
+          {
+            pluginId: plugin.id,
+            field,
+            values: shown,
+            setValue,
+            running,
+            defaultKey: `${plugin.id}.${field.key}`
+          },
+          field.key
+        ))
+      ]
+    }
+  );
+}
+
+// src/ui/shell/ActionSlot.tsx
+init_define_import_meta_env();
+import React3 from "react";
+import { useTranslation as useTranslation3 } from "react-i18next";
+import { Fragment as Fragment2, jsx as jsx6, jsxs as jsxs4 } from "react/jsx-runtime";
+function ActionSlot({
+  slotId,
+  context,
+  className,
+  enabled = true,
+  renderItem,
+  hideLabels,
+  when
+}) {
+  const { t } = useTranslation3();
+  const contributions = useActionSlot(slotId, when).filter(
+    (contribution) => contribution.kind !== "component"
+  );
+  if (!enabled || contributions.length === 0) return null;
+  return /* @__PURE__ */ jsx6(Fragment2, { children: contributions.map((contribution) => {
+    const invoke = () => {
+      void invokeAction(contribution.actionId, ...context?.() ?? []);
+    };
+    if (renderItem) {
+      return /* @__PURE__ */ jsx6(React3.Fragment, { children: renderItem(contribution, invoke) }, contribution.actionId);
+    }
+    const Icon = contribution.icon;
+    const label = t(contribution.titleKey);
+    return /* @__PURE__ */ jsxs4(
+      "button",
+      {
+        type: "button",
+        className,
+        "aria-label": label,
+        title: label,
+        onClick: invoke,
+        children: [
+          Icon && /* @__PURE__ */ jsx6(Icon, { className: "size-4 shrink-0" }),
+          !hideLabels && label
+        ]
+      },
+      contribution.actionId
+    );
+  }) });
+}
+function ComponentSlot({
+  slotId,
+  props,
+  when
+}) {
+  const contributions = useActionSlot(slotId, when).filter(
+    (contribution) => contribution.kind === "component" && contribution.component
+  );
+  if (contributions.length === 0) return null;
+  return /* @__PURE__ */ jsx6(Fragment2, { children: contributions.map((contribution) => {
+    const Contributed = contribution.component;
+    return /* @__PURE__ */ jsx6(Contributed, { ...props ?? {} }, contribution.actionId);
+  }) });
+}
+
+// src/ui/shell/tab-handles.ts
+init_define_import_meta_env();
+import { useSyncExternalStore } from "react";
+var version = 0;
+var listeners = /* @__PURE__ */ new Set();
+var callbacks = /* @__PURE__ */ new WeakMap();
+function subscribe(listener) {
+  listeners.add(listener);
+  return () => listeners.delete(listener);
+}
+function trackTabHandle(ref) {
+  if (!ref) return void 0;
+  let callback = callbacks.get(ref);
+  if (!callback) {
+    callback = (value) => {
+      if (ref.current === value) return;
+      ref.current = value;
+      version += 1;
+      for (const listener of listeners) listener();
+    };
+    callbacks.set(ref, callback);
+  }
+  return callback;
+}
+function useTabHandlesVersion() {
+  return useSyncExternalStore(
+    subscribe,
+    () => version,
+    () => version
+  );
+}
+
+// src/ui/plugin-host/PluginViewPlaceholder.tsx
+init_define_import_meta_env();
+import { useTranslation as useTranslation4 } from "react-i18next";
+import { jsx as jsx7, jsxs as jsxs5 } from "react/jsx-runtime";
+function PluginViewPlaceholder({
+  kind,
+  viewId,
+  compact = false
+}) {
+  const { t } = useTranslation4();
+  usePluginStore();
+  const { has } = usePermissions();
+  const { status, owner } = unregisteredViewStatus(kind, viewId);
+  const name = owner ? pluginName(t, owner.summary) : viewId;
+  if (status === "loading") {
+    return /* @__PURE__ */ jsx7(
+      "div",
+      {
+        className: "flex h-full w-full items-center justify-center",
+        "aria-label": t("plugins.runtime.loading", { name }),
+        children: /* @__PURE__ */ jsx7("div", { className: "size-5 rounded-full border-2 border-muted-foreground/30 border-t-muted-foreground/70 animate-spin" })
+      }
+    );
+  }
+  const title = status === "failed" ? t("plugins.runtime.failed", { name }) : owner ? t("plugins.runtime.needsPlugin", { name }) : t("plugins.runtime.needsUnknownPlugin");
+  const hint = status === "failed" ? t("plugins.runtime.failedHint") : status === "disabled" ? t("plugins.runtime.disabledHint") : t("plugins.runtime.missingHint");
+  return /* @__PURE__ */ jsxs5(
+    "div",
+    {
+      "data-testid": "plugin-view-placeholder",
+      "data-status": status,
+      className: `flex h-full w-full flex-col items-center justify-center gap-2 text-center ${compact ? "p-3" : "p-6"}`,
+      children: [
+        /* @__PURE__ */ jsx7(CircleSlash, { className: "size-6 text-muted-foreground/40" }),
+        /* @__PURE__ */ jsx7("span", { className: "text-sm font-semibold text-muted-foreground", children: title }),
+        /* @__PURE__ */ jsx7("span", { className: "text-xs text-muted-foreground/70", children: hint }),
+        !compact && status !== "failed" && has("admin.plugins.manage") && /* @__PURE__ */ jsx7(
+          Button,
+          {
+            variant: "outline",
+            size: "sm",
+            className: "mt-1",
+            onClick: () => window.dispatchEvent(new CustomEvent(OPEN_PLUGINS_EVENT)),
+            children: t("plugins.manager.browsePlugins")
+          }
+        )
+      ]
+    }
+  );
+}
+
+// src/ui/lib/adaptive-resource-budget.ts
+init_define_import_meta_env();
+
+// src/ui/lib/local-adaptive-engine.ts
+init_define_import_meta_env();
+var LOCAL_ADAPTIVE_ENGINE_KEY = "termix.local.adaptive-engine.v1";
+var VERSION = 1;
+var HALF_LIFE_MS = 30 * 24 * 60 * 60 * 1e3;
+var MAX_SCOPES = 128;
+var MAX_ACTIONS_PER_SCOPE = 12;
+var DEFAULT_MIN_EVIDENCE = 2.5;
+var DEFAULT_MIN_SHARE = 0.6;
+var DEFAULT_MIN_MARGIN = 1;
+var EWMA_ALPHA = 0.25;
+function emptyStore() {
+  return { version: VERSION, scopes: {} };
+}
+function finiteNonNegative(value) {
+  return Number.isFinite(value) && Number(value) >= 0 ? Number(value) : 0;
+}
+function sanitizeAction(value) {
+  if (!value || typeof value !== "object") return null;
+  const stat = value;
+  if (!Number.isFinite(stat.weight) || Number(stat.weight) < 0 || !Number.isFinite(stat.updatedAt)) {
+    return null;
+  }
+  const latencyEwmaMs = finiteNonNegative(stat.latencyEwmaMs);
+  return {
+    weight: Number(stat.weight),
+    updatedAt: Number(stat.updatedAt),
+    observations: finiteNonNegative(stat.observations),
+    successes: finiteNonNegative(stat.successes),
+    cancellations: finiteNonNegative(stat.cancellations),
+    fallbacks: finiteNonNegative(stat.fallbacks),
+    ...latencyEwmaMs > 0 ? { latencyEwmaMs } : {}
+  };
+}
+function sanitizeStore(value) {
+  if (!value || typeof value !== "object") return emptyStore();
+  const candidate = value;
+  if (candidate.version !== VERSION || !candidate.scopes || typeof candidate.scopes !== "object" || Array.isArray(candidate.scopes)) {
+    return emptyStore();
+  }
+  const scopes2 = {};
+  for (const [scope, rawScope] of Object.entries(candidate.scopes)) {
+    if (!rawScope || typeof rawScope !== "object") continue;
+    const value2 = rawScope;
+    if (!Number.isFinite(value2.updatedAt) || !value2.actions || typeof value2.actions !== "object" || Array.isArray(value2.actions)) {
+      continue;
+    }
+    const actions = {};
+    for (const [action, rawStat] of Object.entries(value2.actions)) {
+      const stat = sanitizeAction(rawStat);
+      if (stat) actions[action] = stat;
+    }
+    scopes2[scope] = { actions, updatedAt: Number(value2.updatedAt) };
+  }
+  return { version: VERSION, scopes: scopes2 };
+}
+function readStore() {
+  if (typeof localStorage === "undefined") return emptyStore();
+  try {
+    return sanitizeStore(
+      JSON.parse(localStorage.getItem(LOCAL_ADAPTIVE_ENGINE_KEY) ?? "null")
+    );
+  } catch {
+    return emptyStore();
+  }
+}
+function writeStore(store) {
+  if (typeof localStorage === "undefined") return;
+  try {
+    localStorage.setItem(LOCAL_ADAPTIVE_ENGINE_KEY, JSON.stringify(store));
+  } catch {
+  }
+}
+function decayedWeight(stat, now) {
+  const age = Math.max(0, now - stat.updatedAt);
+  return stat.weight * 2 ** (-age / HALF_LIFE_MS);
+}
+function trimStore(store, now) {
+  for (const scope of Object.values(store.scopes)) {
+    scope.actions = Object.fromEntries(
+      Object.entries(scope.actions).sort(
+        ([, a], [, b]) => decayedWeight(b, now) - decayedWeight(a, now) || b.updatedAt - a.updatedAt
+      ).slice(0, MAX_ACTIONS_PER_SCOPE)
+    );
+  }
+  store.scopes = Object.fromEntries(
+    Object.entries(store.scopes).sort(([, a], [, b]) => b.updatedAt - a.updatedAt).slice(0, MAX_SCOPES)
+  );
+}
+function updateEwma(previous, value) {
+  return previous === void 0 ? value : previous + EWMA_ALPHA * (value - previous);
+}
+function getActionStats(store, scope, action, now) {
+  const scopeStats = store.scopes[scope] ?? { actions: {}, updatedAt: now };
+  return [
+    scopeStats,
+    scopeStats.actions[action] ?? {
+      weight: 0,
+      updatedAt: now,
+      observations: 0,
+      successes: 0,
+      cancellations: 0,
+      fallbacks: 0
+    }
+  ];
+}
+function saveActionStats(store, scope, action, scopeStats, actionStats, now) {
+  scopeStats.actions[action] = actionStats;
+  scopeStats.updatedAt = now;
+  store.scopes[scope] = scopeStats;
+  trimStore(store, now);
+  writeStore(store);
+}
+function recordLocalAdaptiveChoice(scope, action, now = Date.now()) {
+  if (!scope || !action) return;
+  const store = readStore();
+  const [scopeStats, previous] = getActionStats(store, scope, action, now);
+  saveActionStats(
+    store,
+    scope,
+    action,
+    scopeStats,
+    {
+      ...previous,
+      weight: decayedWeight(previous, now) + 1,
+      updatedAt: now
+    },
+    now
+  );
+}
+function recordLocalAdaptiveOutcome(scope, action, outcome, now = Date.now()) {
+  if (!scope || !action || !Object.values(outcome).some((v) => v !== void 0)) {
+    return;
+  }
+  const store = readStore();
+  const [scopeStats, previous] = getActionStats(store, scope, action, now);
+  const latency = finiteNonNegative(outcome.latencyMs);
+  saveActionStats(
+    store,
+    scope,
+    action,
+    scopeStats,
+    {
+      ...previous,
+      updatedAt: now,
+      observations: previous.observations + 1,
+      successes: previous.successes + (outcome.success === true ? 1 : 0),
+      cancellations: previous.cancellations + (outcome.cancelled === true ? 1 : 0),
+      fallbacks: previous.fallbacks + (outcome.fallback === true ? 1 : 0),
+      ...latency > 0 ? { latencyEwmaMs: updateEwma(previous.latencyEwmaMs, latency) } : {}
+    },
+    now
+  );
+}
+function chooseLocalAdaptiveAction({
+  scope,
+  candidates,
+  fallback,
+  now = Date.now(),
+  ttlMs = 5 * 60 * 1e3,
+  minEvidence = DEFAULT_MIN_EVIDENCE,
+  minShare = DEFAULT_MIN_SHARE,
+  minMargin = DEFAULT_MIN_MARGIN
+}) {
+  const expiresAt = now + Math.max(0, ttlMs);
+  const stats = readStore().scopes[scope]?.actions;
+  if (!stats || candidates.length === 0) {
+    return { action: fallback, confidence: 0, reason: "fallback", expiresAt };
+  }
+  const ranked = candidates.map((action) => ({
+    action,
+    weight: stats[action] ? decayedWeight(stats[action], now) : 0
+  })).sort((a, b) => b.weight - a.weight);
+  const total = ranked.reduce((sum, item) => sum + item.weight, 0);
+  const [best, second] = ranked;
+  if (!best || total <= 0) {
+    return { action: fallback, confidence: 0, reason: "fallback", expiresAt };
+  }
+  const share = best.weight / total;
+  const margin = best.weight - (second?.weight ?? 0);
+  const confidence = Math.min(
+    1,
+    best.weight / Math.max(minEvidence, Number.EPSILON),
+    share / Math.max(minShare, Number.EPSILON),
+    margin / Math.max(minMargin, Number.EPSILON)
+  );
+  const learned = best.weight >= minEvidence && share >= minShare && margin >= minMargin;
+  return {
+    action: learned ? best.action : fallback,
+    confidence,
+    reason: learned ? "learned" : "insufficient-evidence",
+    expiresAt
+  };
+}
+function getLocalAdaptiveStats(scope) {
+  return readStore().scopes[scope]?.actions ?? {};
+}
+function clearLocalAdaptiveEngine() {
+  if (typeof localStorage === "undefined") return;
+  try {
+    localStorage.removeItem(LOCAL_ADAPTIVE_ENGINE_KEY);
+  } catch {
+  }
+}
+
+// src/ui/lib/adaptive-resource-budget.ts
+var scopes = {
+  module: "resource-budget:module",
+  network: "resource-budget:network"
+};
+var usefulnessScopes = {
+  module: "resource-usefulness:module",
+  network: "resource-usefulness:network"
+};
+var PRELOAD_USE_WINDOW_MS = 1e4;
+var pendingPreloads = /* @__PURE__ */ new Map();
+var activeTasks = {
+  module: 0,
+  network: 0
+};
+var budgets = {
+  paused: {
+    tier: "paused",
+    allowModulePreload: false,
+    allowNetworkPrefetch: false,
+    maxPrefetchBytes: 0,
+    maxConcurrentModulePreloads: 0,
+    maxConcurrentNetworkPrefetches: 0,
+    reason: "hidden"
+  },
+  constrained: {
+    tier: "constrained",
+    allowModulePreload: false,
+    allowNetworkPrefetch: false,
+    maxPrefetchBytes: 0,
+    maxConcurrentModulePreloads: 0,
+    maxConcurrentNetworkPrefetches: 0,
+    reason: "environment"
+  },
+  balanced: {
+    tier: "balanced",
+    allowModulePreload: true,
+    allowNetworkPrefetch: true,
+    maxPrefetchBytes: 128 * 1024,
+    maxConcurrentModulePreloads: 1,
+    maxConcurrentNetworkPrefetches: 1,
+    reason: "environment"
+  },
+  eager: {
+    tier: "eager",
+    allowModulePreload: true,
+    allowNetworkPrefetch: true,
+    maxPrefetchBytes: 512 * 1024,
+    maxConcurrentModulePreloads: 2,
+    maxConcurrentNetworkPrefetches: 2,
+    reason: "default"
+  }
+};
+function withReason(tier, reason) {
+  return { ...budgets[tier], reason };
+}
+function feedbackIsPoor(feedback) {
+  if (!feedback || feedback.observations < 4) return false;
+  const failureRate = 1 - feedback.successes / feedback.observations;
+  const abandoned = feedback.cancellations + feedback.fallbacks;
+  return failureRate > 0.25 || abandoned / feedback.observations > 0.25 || (feedback.latencyEwmaMs ?? 0) > 2e3 || (feedback.usefulnessObservations ?? 0) >= 4 && (feedback.usefulPreloads ?? 0) / (feedback.usefulnessObservations ?? 1) < 0.25;
+}
+function preloadKey(kind, action) {
+  return `${kind}:${action}`;
+}
+function flushExpiredPreloads(now = Date.now()) {
+  for (const [key, preload] of pendingPreloads) {
+    if (preload.expiresAt > now) continue;
+    recordLocalAdaptiveOutcome(usefulnessScopes[preload.kind], preload.action, {
+      success: false
+    });
+    pendingPreloads.delete(key);
+  }
+}
+function markAdaptiveResourceUsed(kind, action, now = Date.now()) {
+  flushExpiredPreloads(now);
+  const key = preloadKey(kind, action);
+  if (!pendingPreloads.has(key)) return;
+  pendingPreloads.delete(key);
+  recordLocalAdaptiveOutcome(
+    usefulnessScopes[kind],
+    action,
+    { success: true },
+    now
+  );
+}
+function computeAdaptiveResourceBudget(environment, feedback) {
+  if (!environment.visible) return withReason("paused", "hidden");
+  if (environment.saveData || ["slow-2g", "2g", "3g"].includes(environment.effectiveType ?? "")) {
+    return withReason("constrained", "environment");
+  }
+  const limitedDevice = (environment.deviceMemoryGb ?? 8) <= 4 || (environment.hardwareConcurrency ?? 8) <= 4;
+  const baseline = limitedDevice ? "balanced" : "eager";
+  if (!feedbackIsPoor(feedback)) {
+    return withReason(baseline, limitedDevice ? "environment" : "default");
+  }
+  return withReason(
+    baseline === "eager" ? "balanced" : "constrained",
+    "feedback"
+  );
+}
+function readEnvironment() {
+  const navigatorLike = typeof navigator === "undefined" ? void 0 : navigator;
+  return {
+    visible: typeof document === "undefined" || document.visibilityState !== "hidden",
+    saveData: navigatorLike?.connection?.saveData,
+    effectiveType: navigatorLike?.connection?.effectiveType,
+    deviceMemoryGb: navigatorLike?.deviceMemory,
+    hardwareConcurrency: navigatorLike?.hardwareConcurrency
+  };
+}
+function readFeedback(kind) {
+  flushExpiredPreloads();
+  const stats = Object.values(getLocalAdaptiveStats(scopes[kind]));
+  const usefulness = Object.values(
+    getLocalAdaptiveStats(usefulnessScopes[kind])
+  );
+  const observations = stats.reduce((sum, stat) => sum + stat.observations, 0);
+  const latencySamples = stats.filter(
+    (stat) => stat.latencyEwmaMs !== void 0 && stat.observations > 0
+  );
+  const latencyWeight = latencySamples.reduce(
+    (sum, stat) => sum + stat.observations,
+    0
+  );
+  return {
+    observations,
+    successes: stats.reduce((sum, stat) => sum + stat.successes, 0),
+    cancellations: stats.reduce((sum, stat) => sum + stat.cancellations, 0),
+    fallbacks: stats.reduce((sum, stat) => sum + stat.fallbacks, 0),
+    usefulnessObservations: usefulness.reduce(
+      (sum, stat) => sum + stat.observations,
+      0
+    ),
+    usefulPreloads: usefulness.reduce((sum, stat) => sum + stat.successes, 0),
+    ...latencyWeight > 0 ? {
+      latencyEwmaMs: latencySamples.reduce(
+        (sum, stat) => sum + (stat.latencyEwmaMs ?? 0) * stat.observations,
+        0
+      ) / latencyWeight
+    } : {}
+  };
+}
+function getAdaptiveResourceBudget(kind) {
+  return computeAdaptiveResourceBudget(readEnvironment(), readFeedback(kind));
+}
+function runAdaptiveBackgroundTask(kind, action, task, options = {}) {
+  const budget = getAdaptiveResourceBudget(kind);
+  const allowed = kind === "module" ? budget.allowModulePreload : budget.allowNetworkPrefetch && (options.estimatedBytes === void 0 || options.estimatedBytes <= budget.maxPrefetchBytes);
+  const concurrency = kind === "module" ? budget.maxConcurrentModulePreloads : budget.maxConcurrentNetworkPrefetches;
+  if (!allowed || activeTasks[kind] >= concurrency) return false;
+  activeTasks[kind] += 1;
+  const key = preloadKey(kind, action);
+  pendingPreloads.set(key, {
+    kind,
+    action,
+    expiresAt: Date.now() + PRELOAD_USE_WINDOW_MS
+  });
+  const startedAt = performance.now();
+  void Promise.resolve().then(task).then(
+    () => {
+      activeTasks[kind] -= 1;
+      recordLocalAdaptiveOutcome(scopes[kind], action, {
+        success: true,
+        latencyMs: performance.now() - startedAt
+      });
+    },
+    () => {
+      activeTasks[kind] -= 1;
+      pendingPreloads.delete(key);
+      recordLocalAdaptiveOutcome(scopes[kind], action, {
+        success: false,
+        latencyMs: performance.now() - startedAt
+      });
+    }
+  );
+  return true;
+}
+
+// src/ui/shell/tabUtils.tsx
+init_define_import_meta_env();
+import { lazy, memo as memo2, Suspense } from "react";
+import { useTranslation as useTranslation6 } from "react-i18next";
+
+// src/ui/shell/CompanionFrame.tsx
+init_define_import_meta_env();
+import {
+  memo,
+  useCallback,
+  useEffect as useEffect2,
+  useMemo as useMemo2,
+  useRef,
+  useState as useState3
+} from "react";
+import { useTranslation as useTranslation5 } from "react-i18next";
+import { Fragment as Fragment3, jsx as jsx8, jsxs as jsxs6 } from "react/jsx-runtime";
+var DEFAULT_SIDE_SIZE = 360;
+var DEFAULT_BOTTOM_SIZE = 280;
+var MIN_SIZE = 200;
+function DefaultsReader({
+  def,
+  onValue
+}) {
+  const Reader = def.Defaults;
+  const report = useCallback(
+    (value) => onValue(def.id, value),
+    [def.id, onValue]
+  );
+  return Reader ? /* @__PURE__ */ jsx8(Reader, { onValue: report }) : null;
+}
+function sideIcon(side) {
+  if (side === "left") return ArrowLeftToLine;
+  if (side === "bottom") return ArrowDownToLine;
+  return ArrowRightToLine;
+}
+var CompanionFrame = memo(function CompanionFrame2({
+  tab,
+  isVisible,
+  children
+}) {
+  const defs = useCompanionDefs();
+  const layoutDefs = useCompanionLayoutDefs();
+  const applicable = useMemo2(
+    () => arrangeCompanions(
+      defs.filter((def) => companionApplies(def, tab)),
+      resolveCompanionLayout(tab.type, tab.host).order
+    ),
+    // tab.host and tab.type decide it
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [defs, layoutDefs, tab.type, tab.host]
+  );
+  if (applicable.length === 0) return /* @__PURE__ */ jsx8(Fragment3, { children });
+  return /* @__PURE__ */ jsx8(CompanionLayout, { tab, defs: applicable, isVisible, children });
+});
+function CompanionLayout({
+  tab,
+  defs,
+  isVisible,
+  children
+}) {
+  const { t } = useTranslation5();
+  const isMobile = useIsMobile();
+  const key = companionKey(tab);
+  const state = useCompanionState(key);
+  const [defaults, setDefaults] = useState3(
+    {}
+  );
+  const [dragging, setDragging] = useState3(false);
+  const [mounted, setMounted] = useState3(/* @__PURE__ */ new Set());
+  const rootRef = useRef(null);
+  const onDefaults = useCallback((id, value) => {
+    setDefaults((prev) => {
+      const old = prev[id];
+      if (old && old.open === value.open && old.side === value.side && old.size === value.size && old.edgeButton === value.edgeButton) {
+        return prev;
+      }
+      return { ...prev, [id]: value };
+    });
+  }, []);
+  useEffect2(() => {
+    if (state.seen || !isVisible) return;
+    const ready = defs.every(
+      (def) => !def.Defaults || defaults[def.id] !== void 0
+    );
+    if (!ready) return;
+    const auto = defs.find((def) => defaults[def.id]?.open);
+    patchCompanionState(key, { seen: true, openId: auto?.id ?? null });
+  }, [state.seen, isVisible, defs, defaults, key]);
+  const active = defs.find((def) => def.id === state.openId) ?? null;
+  useEffect2(() => {
+    if (!active) return;
+    setMounted(
+      (prev) => prev.has(active.id) ? prev : new Set(prev).add(active.id)
+    );
+  }, [active]);
+  const activeDefaults = active ? defaults[active.id] : void 0;
+  const layout = useMemo2(
+    () => resolveCompanionLayout(tab.type, tab.host),
+    [tab.type, tab.host]
+  );
+  const side = isMobile ? "bottom" : state.side ?? layout.side ?? activeDefaults?.side ?? "right";
+  const baseSize = state.size ?? activeDefaults?.size ?? (side === "bottom" ? DEFAULT_BOTTOM_SIZE : DEFAULT_SIDE_SIZE);
+  const setSide = useCallback(
+    (next) => patchCompanionState(key, { side: next }),
+    [key]
+  );
+  const close = useCallback(
+    () => patchCompanionState(key, { openId: null }),
+    [key]
+  );
+  const startResize = (event) => {
+    event.preventDefault();
+    const root = rootRef.current;
+    if (!root) return;
+    const rect = root.getBoundingClientRect();
+    const total = side === "bottom" ? rect.height : rect.width;
+    const max = Math.max(MIN_SIZE, total - MIN_SIZE);
+    setDragging(true);
+    const move = (e) => {
+      const raw = side === "right" ? rect.right - e.clientX : side === "left" ? e.clientX - rect.left : rect.bottom - e.clientY;
+      patchCompanionState(key, {
+        size: Math.round(Math.min(max, Math.max(MIN_SIZE, raw)))
+      });
+    };
+    const up = () => {
+      setDragging(false);
+      window.removeEventListener("mousemove", move);
+      window.removeEventListener("mouseup", up);
+    };
+    window.addEventListener("mousemove", move);
+    window.addEventListener("mouseup", up);
+  };
+  const getHandle = useCallback(
+    () => tab.terminalRef?.current ?? null,
+    [tab.terminalRef]
+  );
+  const sshHost = useMemo2(
+    () => tab.host ? hostToSSHHost(tab.host) : void 0,
+    [tab.host]
+  );
+  const showEdge = defs.filter((def) => defaults[def.id]?.edgeButton !== false);
+  const vertical = side === "bottom";
+  const clamped = vertical ? Math.min(baseSize, 2e3) : baseSize;
+  const paneStyle = isMobile ? { height: "55%" } : vertical ? { height: clamped } : { width: clamped };
+  const SideIcon = sideIcon(side);
+  return /* @__PURE__ */ jsxs6("div", { className: "flex h-full w-full min-h-0 min-w-0", children: [
+    defs.map(
+      (def) => def.Defaults ? /* @__PURE__ */ jsx8(DefaultsReader, { def, onValue: onDefaults }, def.id) : null
+    ),
+    /* @__PURE__ */ jsxs6(
+      "div",
+      {
+        ref: rootRef,
+        className: cn(
+          "relative flex flex-1 min-h-0 min-w-0",
+          vertical ? "flex-col" : side === "left" ? "flex-row-reverse" : "flex-row"
+        ),
+        children: [
+          /* @__PURE__ */ jsx8("div", { className: "relative flex-1 min-h-0 min-w-0", children }),
+          defs.map((def) => {
+            if (!mounted.has(def.id)) return null;
+            const open = active?.id === def.id;
+            const Component = def.component;
+            const Icon = def.icon;
+            return /* @__PURE__ */ jsxs6(
+              "div",
+              {
+                className: cn(
+                  "relative flex-shrink-0 flex-col min-h-0 min-w-0 bg-background border-border",
+                  open ? "flex" : "hidden",
+                  vertical ? "border-t" : side === "left" ? "border-r" : "border-l",
+                  isMobile && "absolute inset-x-0 bottom-0 z-20 shadow-lg"
+                ),
+                style: paneStyle,
+                children: [
+                  !isMobile && /* @__PURE__ */ jsx8(
+                    "div",
+                    {
+                      role: "separator",
+                      "aria-label": t("companion.resize"),
+                      onMouseDown: startResize,
+                      className: cn(
+                        "absolute z-10",
+                        vertical ? "inset-x-0 -top-1 h-2 cursor-row-resize" : side === "left" ? "inset-y-0 -right-1 w-2 cursor-col-resize" : "inset-y-0 -left-1 w-2 cursor-col-resize",
+                        dragging && "bg-primary/30"
+                      )
+                    }
+                  ),
+                  /* @__PURE__ */ jsxs6("div", { className: "flex items-center gap-1.5 h-8 px-2 border-b border-border flex-shrink-0", children: [
+                    Icon && /* @__PURE__ */ jsx8(Icon, { className: "size-3.5 text-muted-foreground" }),
+                    /* @__PURE__ */ jsx8("span", { className: "text-xs font-medium truncate flex-1", children: def.titleKey ? t(def.titleKey) : def.id }),
+                    !isMobile && /* @__PURE__ */ jsx8(
+                      "button",
+                      {
+                        type: "button",
+                        className: "p-1 text-muted-foreground hover:text-foreground",
+                        title: t("companion.moveSide"),
+                        onClick: () => setSide(
+                          side === "right" ? "bottom" : side === "bottom" ? "left" : "right"
+                        ),
+                        children: /* @__PURE__ */ jsx8(SideIcon, { className: "size-3.5" })
+                      }
+                    ),
+                    /* @__PURE__ */ jsx8(
+                      "button",
+                      {
+                        type: "button",
+                        className: "p-1 text-muted-foreground hover:text-foreground",
+                        title: t("companion.close"),
+                        onClick: close,
+                        children: /* @__PURE__ */ jsx8(X, { className: "size-3.5" })
+                      }
+                    )
+                  ] }),
+                  /* @__PURE__ */ jsx8("div", { className: "flex-1 min-h-0 min-w-0 overflow-hidden", children: /* @__PURE__ */ jsx8(
+                    Component,
+                    {
+                      tab,
+                      host: tab.host,
+                      sshHost,
+                      getHandle,
+                      side,
+                      isVisible: isVisible && open,
+                      close,
+                      setSide
+                    }
+                  ) })
+                ]
+              },
+              def.id
+            );
+          })
+        ]
+      }
+    ),
+    showEdge.length > 0 && !isMobile && /* @__PURE__ */ jsx8("div", { className: "flex flex-col flex-shrink-0 w-6 items-center gap-1 pt-1 border-l border-border bg-background", children: showEdge.map((def) => {
+      const Icon = def.icon ?? PanelRight;
+      const open = active?.id === def.id;
+      return /* @__PURE__ */ jsx8(
+        "button",
+        {
+          type: "button",
+          title: def.titleKey ? t(def.titleKey) : def.id,
+          "aria-pressed": open,
+          onClick: () => patchCompanionState(key, {
+            seen: true,
+            openId: open ? null : def.id
+          }),
+          className: cn(
+            "p-1 text-muted-foreground hover:text-foreground",
+            open && "text-foreground bg-accent"
+          ),
+          children: /* @__PURE__ */ jsx8(Icon, { className: "size-3.5" })
+        },
+        def.id
+      );
+    }) })
+  ] });
+}
+
+// src/ui/shell/tabUtils.tsx
+import { jsx as jsx9, jsxs as jsxs7 } from "react/jsx-runtime";
+var PluginsTab = lazy(
+  () => import("./PluginsTab-CM2B33BD.js").then((m) => ({ default: m.PluginsTab }))
+);
+function preloadTabSurface(type) {
+  const loader = getTabType(type)?.preload;
+  if (loader) runAdaptiveBackgroundTask("module", `tab:${type}`, loader);
+}
+function markTabSurfaceUsed(type) {
+  markAdaptiveResourceUsed("module", `tab:${type}`);
+}
+function EmptyState({
+  icon: Icon,
+  messageKey
+}) {
+  const { t } = useTranslation6();
+  return /* @__PURE__ */ jsxs7("div", { className: "flex flex-col items-center justify-center flex-1 gap-3 p-6 text-center", children: [
+    /* @__PURE__ */ jsx9("div", { className: "size-10 rounded-full bg-muted/40 flex items-center justify-center", children: /* @__PURE__ */ jsx9(Icon, { className: "size-5 text-muted-foreground/30" }) }),
+    /* @__PURE__ */ jsx9("span", { className: "text-sm font-semibold text-muted-foreground/60", children: t(messageKey) })
+  ] });
+}
+function TabChunkFallback() {
+  return /* @__PURE__ */ jsx9("div", { className: "flex h-full w-full items-center justify-center bg-background", children: /* @__PURE__ */ jsx9("div", { className: "size-5 rounded-full border-2 border-muted-foreground/30 border-t-muted-foreground/70 animate-spin" }) });
+}
+function withTabSuspense(node) {
+  return /* @__PURE__ */ jsx9(Suspense, { fallback: /* @__PURE__ */ jsx9(TabChunkFallback, {}), children: node });
+}
+function PanelTabFrame({ children }) {
+  return /* @__PURE__ */ jsx9("div", { className: "flex h-full w-full justify-center overflow-y-auto bg-background", children: /* @__PURE__ */ jsx9("div", { className: "flex flex-col flex-1 min-h-0 w-full max-w-5xl", children }) });
+}
+function tabIcon(type) {
+  switch (type) {
+    case "user-profile":
+    case "admin-settings":
+      return /* @__PURE__ */ jsx9(Settings, { className: "size-3.5" });
+    case "split-screen":
+      return /* @__PURE__ */ jsx9(LayoutPanelLeft, { className: "size-3.5" });
+    case "plugins":
+      return /* @__PURE__ */ jsx9(Puzzle, { className: "size-3.5" });
+    default: {
+      const Icon = getTabType(type)?.icon;
+      return Icon ? /* @__PURE__ */ jsx9(Icon, { className: "size-3.5" }) : null;
+    }
+  }
+}
+var RegisteredTab = memo2(function RegisteredTab2({
+  def,
+  tab,
+  isVisible,
+  isFocusedPane,
+  inSplit,
+  shell
+}) {
+  const { host, label } = tab;
+  if (def.requiresHost && !host) {
+    return /* @__PURE__ */ jsx9(
+      EmptyState,
+      {
+        icon: Server,
+        messageKey: def.noHostMessageKey ?? "hosts.noHostSelected"
+      }
+    );
+  }
+  const Component = def.component;
+  const content = /* @__PURE__ */ jsx9(
+    Component,
+    {
+      tab,
+      host,
+      sshHost: host ? hostToSSHHost(host) : void 0,
+      label,
+      isVisible,
+      isFocusedPane,
+      inSplit,
+      handleRef: trackTabHandle(
+        tab.terminalRef
+      ),
+      shell
+    }
+  );
+  return withTabSuspense(
+    /* @__PURE__ */ jsx9(CompanionFrame, { tab, isVisible, children: def.panelFrame ? /* @__PURE__ */ jsx9(PanelTabFrame, { children: content }) : content })
+  );
+});
+var PanelAsTab = memo2(function PanelAsTab2({
+  panel,
+  isVisible,
+  targetTab,
+  shell
+}) {
+  const Panel = panel.component;
+  return withTabSuspense(
+    /* @__PURE__ */ jsx9(PanelTabFrame, { children: /* @__PURE__ */ jsx9(
+      Panel,
+      {
+        targetTab,
+        active: isVisible,
+        shell,
+        setEditing: noop,
+        placement: "tab"
+      }
+    ) })
+  );
+});
+function noop() {
+}
+function renderTabContent(tab, context) {
+  const {
+    shell,
+    isVisible = true,
+    isFocusedPane = true,
+    inSplit = false
+  } = context;
+  switch (tab.type) {
+    case "split-screen":
+      return null;
+    case "plugins":
+      return withTabSuspense(/* @__PURE__ */ jsx9(PluginsTab, {}));
+    case "user-profile":
+    case "admin-settings":
+      return null;
+    default: {
+      const def = getTabType(tab.type);
+      if (!def && tab.type === "dashboard") return null;
+      if (!def) {
+        const panel = getPanel(tab.type);
+        if (panel) {
+          return /* @__PURE__ */ jsx9(
+            PanelAsTab,
+            {
+              panel,
+              isVisible,
+              targetTab: context.panelTargetTab,
+              shell
+            }
+          );
+        }
+        return /* @__PURE__ */ jsx9(PluginViewPlaceholder, { kind: "tab", viewId: tab.type });
+      }
+      return /* @__PURE__ */ jsx9(
+        RegisteredTab,
+        {
+          def,
+          tab,
+          isVisible,
+          isFocusedPane,
+          inSplit,
+          shell
+        }
+      );
+    }
+  }
+}
+
+// src/ui/lib/local-adaptive-preferences.ts
+init_define_import_meta_env();
+var LOCAL_ADAPTIVE_PREFERENCES_KEY = LOCAL_ADAPTIVE_ENGINE_KEY;
+function recordLocalPreference(scope, action, now = Date.now()) {
+  recordLocalAdaptiveChoice(scope, action, now);
+}
+function getLocalPreference(scope, candidates, fallback, now = Date.now()) {
+  return chooseLocalAdaptiveAction({
+    scope,
+    candidates,
+    fallback,
+    now
+  }).action;
+}
+function clearLocalAdaptivePreferences() {
+  clearLocalAdaptiveEngine();
+}
+var hostActionScope = (hostId) => `host-action:${hostId}`;
+function recordHostActionPreference(hostId, action) {
+  recordLocalPreference(hostActionScope(hostId), action);
+}
+function getPreferredHostAction(hostId, candidates, fallback) {
+  return getLocalPreference(hostActionScope(hostId), candidates, fallback);
+}
+
+export {
+  Checkbox2 as Checkbox,
+  PasswordInput,
+  Textarea,
+  useInstalledPlugins,
+  SettingsFieldRow,
+  usePluginHostSections,
+  HostPluginSections,
+  HostFeatureFields,
+  ActionSlot,
+  ComponentSlot,
+  trackTabHandle,
+  useTabHandlesVersion,
+  PluginViewPlaceholder,
+  markAdaptiveResourceUsed,
+  getAdaptiveResourceBudget,
+  runAdaptiveBackgroundTask,
+  preloadTabSurface,
+  markTabSurfaceUsed,
+  tabIcon,
+  renderTabContent,
+  LOCAL_ADAPTIVE_PREFERENCES_KEY,
+  clearLocalAdaptivePreferences,
+  recordHostActionPreference,
+  getPreferredHostAction
+};