gloomberb 0.15.2 → 0.15.3

package/src/plugins/auto-update.ts

@@ -0,0 +1,281 @@
+import type { AppConfig } from "../types/config";
+import { requiredGloomberb } from "../utils/semver";
+import { VERSION } from "../version";
+import { findAbsorbedPlugin } from "./absorbed";
+import { applicationPluginMeta } from "./builtin/builtin-plugin-meta";
+import { hasUpdate, type RegistryPlugin } from "./builtin/plugin-marketplace/model";
+import type { PluginOperationResult, PluginPin } from "./builtin/plugin-marketplace/store";
+
+/**
+ * Keeps official plugins current without their users having to.
+ *
+ * Gloomberb updates itself, but a plugin moves only when it is updated, so a
+ * host release that retires an API would strand every checkout still using
+ * it. Plugins Gloom publishes (registry entries whose repository gloom-sh
+ * owns) therefore update in the background: once after Gloomberb itself
+ * changed version, then at most once a day, and at startup for one that
+ * failed to load on a host export this build does not have.
+ *
+ * An automatic update takes the same guards as the Plugins pane's: it only
+ * moves forward, never to code this Gloomberb is too old for, never over a
+ * linked or locally edited checkout, and peers first. Third-party plugins,
+ * and anything installed from a repository the registry does not list, are
+ * left to their users. A leftover checkout of a plugin that is built in now
+ * (absorbed.ts) is never pulled, however stale the registry.
+ */
+
+export const OFFICIAL_PLUGIN_OWNER = "gloom-sh";
+
+/**
+ * The Plugins pane setting, kept in the config of the built-in plugin that
+ * owns the pane. Absent means on.
+ */
+export const PLUGIN_AUTO_UPDATE_SETTING = { pluginId: applicationPluginMeta.id, key: "autoUpdateOfficialPlugins" } as const;
+
+export function pluginAutoUpdateEnabled(config: Pick<AppConfig, "pluginConfig"> | null | undefined): boolean {
+  const { pluginId, key } = PLUGIN_AUTO_UPDATE_SETTING;
+  return config?.pluginConfig?.[pluginId]?.[key] !== false;
+}
+
+export function isOfficialPluginRepo(repo: string | null | undefined): boolean {
+  return repo?.split("/")[0]?.toLowerCase() === OFFICIAL_PLUGIN_OWNER;
+}
+
+/** An installed plugin folder, as it is on disk. */
+export interface PluginCheckout {
+  directory: string;
+  /** The id its gloom.json declares, if it has one. */
+  id: string | null;
+  /** `owner/repo` of its origin remote; null for anything that is not a GitHub clone. */
+  repo: string | null;
+  commit: string | null;
+  /** package.json `version`. */
+  version: string | null;
+  linked: boolean;
+  /** The Gloomberb the checkout declares it needs, when this one is older. */
+  needsGloomberb: string | null;
+  /** Folders of the installed sibling plugins it declares as peers. */
+  peers: string[];
+  /** Declares runtime dependencies, which only `bun install` can fetch. */
+  hasDependencies: boolean;
+}
+
+export interface PluginAutoUpdateDeps {
+  checkouts(): Promise<PluginCheckout[]>;
+  /** The registry's plugins, or null when it could not be read. */
+  registry(): Promise<readonly RegistryPlugin[] | null>;
+  /** Where the checkout's remote default branch is, for a plugin the registry does not pin. */
+  remoteHead(directory: string): Promise<string | null>;
+  hasLocalChanges(directory: string): Promise<boolean>;
+  /** Whether `bun` is there to install a plugin's dependencies. */
+  hasBun(): boolean;
+  update(directory: string, pin: PluginPin | undefined): Promise<PluginOperationResult>;
+  log(message: string): void;
+  hostVersion?: string;
+}
+
+export interface PluginAutoUpdateResult {
+  /** False when the registry could not be read, so nothing was decided. */
+  checked: boolean;
+  /** Folders whose checkout moved to a newer commit. */
+  updated: string[];
+}
+
+interface Candidate {
+  checkout: PluginCheckout;
+  pin: PluginPin | undefined;
+}
+
+/** Peers before the plugins that declare them, so a dependent never lands ahead of the peer version it needs. */
+function peersFirst(candidates: readonly Candidate[]): Candidate[] {
+  const byDirectory = new Map(candidates.map((candidate) => [candidate.checkout.directory, candidate]));
+  const ordered: Candidate[] = [];
+  const seen = new Set<string>();
+  const visit = (candidate: Candidate) => {
+    if (seen.has(candidate.checkout.directory)) return;
+    seen.add(candidate.checkout.directory);
+    for (const peer of candidate.checkout.peers) {
+      const dependency = byDirectory.get(peer);
+      if (dependency) visit(dependency);
+    }
+    ordered.push(candidate);
+  };
+  candidates.forEach(visit);
+  return ordered;
+}
+
+/**
+ * Updates every official plugin that has a newer compatible version, or only
+ * the folders in `only`. Never throws for one plugin: a failure is logged and
+ * the rest carry on, except a plugin whose peer had an update it did not get.
+ */
+export async function runPluginAutoUpdate(
+  deps: PluginAutoUpdateDeps,
+  only?: readonly string[],
+): Promise<PluginAutoUpdateResult> {
+  const registry = await deps.registry();
+  if (!registry) {
+    deps.log("Skipped the plugin update check: the plugin registry is unreachable.");
+    return { checked: false, updated: [] };
+  }
+  const listings = new Map(
+    registry.filter((plugin) => plugin.repo).map((plugin) => [plugin.repo!.toLowerCase(), plugin]),
+  );
+  const hostVersion = deps.hostVersion ?? VERSION;
+  const candidates: Candidate[] = [];
+  // Had a newer version and did not get it, so a plugin built on it waits too.
+  const held = new Set<string>();
+  const skip = (directory: string, reason: string) => {
+    held.add(directory);
+    deps.log(`Not updating ${directory}: ${reason}.`);
+  };
+
+  for (const checkout of await deps.checkouts()) {
+    const { directory } = checkout;
+    if (only && !only.includes(directory)) continue;
+    const absorbed = findAbsorbedPlugin(checkout);
+    if (absorbed) {
+      deps.log(`Not updating ${directory}: ${absorbed.name} is built into Gloomberb now.`);
+      continue;
+    }
+    const listing = checkout.repo ? listings.get(checkout.repo.toLowerCase()) : undefined;
+    // Third-party and unlisted plugins are their users' to update.
+    if (!listing || !isOfficialPluginRepo(listing.repo)) continue;
+    if (checkout.linked) {
+      deps.log(`Not updating ${directory}: it is linked to a local checkout.`);
+      continue;
+    }
+    const required = requiredGloomberb(listing.minGloomberb, hostVersion) ?? checkout.needsGloomberb;
+    if (required) {
+      deps.log(`Not updating ${directory}: it needs Gloomberb ${required}, this is ${hostVersion}.`);
+      continue;
+    }
+    const pin: PluginPin | undefined = listing.ref || listing.commit
+      ? { ...(listing.ref ? { ref: listing.ref } : {}), ...(listing.commit ? { commit: listing.commit } : {}) }
+      : undefined;
+    // The same test the Plugins pane uses for its `update` status.
+    const newer = hasUpdate({
+      installed: true,
+      bundled: false,
+      linked: false,
+      installedVersion: checkout.version ?? undefined,
+      installedCommit: checkout.commit ?? undefined,
+      availableVersion: listing.ref,
+      availableCommit: listing.commit,
+      remoteCommit: pin ? undefined : (await deps.remoteHead(directory)) ?? undefined,
+    });
+    if (!newer) continue;
+    if (await deps.hasLocalChanges(directory)) {
+      skip(directory, "it has local changes");
+      continue;
+    }
+    if (checkout.hasDependencies && !deps.hasBun()) {
+      skip(directory, "bun is not on PATH to install its dependencies");
+      continue;
+    }
+    candidates.push({ checkout, pin });
+  }
+
+  const updated: string[] = [];
+  for (const { checkout, pin } of peersFirst(candidates)) {
+    const { directory } = checkout;
+    const heldPeer = checkout.peers.find((peer) => held.has(peer));
+    if (heldPeer) {
+      skip(directory, `its peer ${heldPeer} was not updated`);
+      continue;
+    }
+    const result = await deps.update(directory, pin);
+    if (!result.ok) {
+      held.add(directory);
+      deps.log(`Updating ${directory} failed: ${result.error}`);
+    } else if (result.kept) {
+      deps.log(`Kept ${directory}: ${result.kept}.`);
+    } else if (result.changed !== false) {
+      deps.log(`Updated ${directory}.`);
+      updated.push(directory);
+    }
+  }
+  return { checked: true, updated };
+}
+
+const DAY_MS = 24 * 60 * 60_000;
+
+/** What the last full check left behind, so the schedule holds across launches. */
+export interface PluginAutoUpdateState {
+  /** When it last read the registry. */
+  checkedAt: number;
+  /** The Gloomberb that ran it. */
+  hostVersion: string;
+}
+
+/** A full check is due once on every new Gloomberb version, and then once a day. */
+export function pluginAutoUpdateDue(
+  state: PluginAutoUpdateState | null,
+  now: number,
+  hostVersion: string = VERSION,
+): boolean {
+  if (!state || state.hostVersion !== hostVersion) return true;
+  return now - state.checkedAt >= DAY_MS;
+}
+
+export interface PluginAutoUpdateSchedule {
+  isEnabled(): boolean | Promise<boolean>;
+  run(only?: readonly string[]): Promise<PluginAutoUpdateResult>;
+  /** Plugin folders that failed to load on a missing host export this session. */
+  missingHostExports(): readonly string[];
+  readState(): PluginAutoUpdateState | null;
+  writeState(state: PluginAutoUpdateState): void;
+  onUpdated(directories: string[]): void | Promise<void>;
+  log(message: string): void;
+  now?(): number;
+  hostVersion?: string;
+}
+
+/**
+ * One pass of the schedule. A full check runs when one is due; at startup,
+ * plugins that failed on a missing host export are checked even when it is
+ * not, since a newer version is what would fix them. Passes never overlap.
+ */
+export function createPluginAutoUpdateScheduler(schedule: PluginAutoUpdateSchedule): { tick(startup: boolean): Promise<void> } {
+  let running = false;
+  return {
+    async tick(startup) {
+      if (running) return;
+      running = true;
+      try {
+        if (!(await schedule.isEnabled())) return;
+        const now = schedule.now?.() ?? Date.now();
+        const hostVersion = schedule.hostVersion ?? VERSION;
+        const due = pluginAutoUpdateDue(schedule.readState(), now, hostVersion);
+        const only = due ? undefined : startup ? schedule.missingHostExports() : [];
+        if (only && only.length === 0) return;
+        const result = await schedule.run(only);
+        // Offline is not a check: the next pass tries again.
+        if (due && result.checked) schedule.writeState({ checkedAt: now, hostVersion });
+        if (result.updated.length > 0) await schedule.onUpdated(result.updated);
+      } catch (error) {
+        schedule.log(`The plugin update check failed: ${error instanceof Error ? error.message : String(error)}`);
+      } finally {
+        running = false;
+      }
+    },
+  };
+}
+
+/** Well after the first frame and the startup data loads. */
+const STARTUP_DELAY_MS = 15_000;
+/** How often to look whether a day has passed; the check itself runs daily. */
+const POLL_INTERVAL_MS = 60 * 60_000;
+
+/** Runs the schedule until the returned function is called. The timers never keep a process alive. */
+export function startPluginAutoUpdates(schedule: PluginAutoUpdateSchedule): () => void {
+  const scheduler = createPluginAutoUpdateScheduler(schedule);
+  const startup = setTimeout(() => { void scheduler.tick(true); }, STARTUP_DELAY_MS);
+  const interval = setInterval(() => { void scheduler.tick(false); }, POLL_INTERVAL_MS);
+  startup.unref?.();
+  interval.unref?.();
+  return () => {
+    clearTimeout(startup);
+    clearInterval(interval);
+  };
+}

package/src/plugins/builtin/account-management/form-components.tsx

@@ -1,84 +1,12 @@
 import { type ReactNode, type Ref } from "react";
-import { Checkbox, SelectButton, TextField, type ChoiceDialogChoice } from "../../../components";
-import { Box, Text, TextAttributes, useUiCapabilities, type BoxRenderable } from "../../../ui";
+import { Checkbox, FieldLabel, SelectButton, type ChoiceDialogChoice } from "../../../components";
+import { Box, Text, TextAttributes, type BoxRenderable } from "../../../ui";
 import { colors } from "../../../theme/colors";
+import { truncateWithEllipsis } from "../../../utils/text-wrap";
 import type { SelectControl } from "../../../components/ui/select-button";
-import type { AccountFieldKey, ProfileAnalyticsPreview } from "./model";
-import { truncate } from "./model";
+import type { ProfileAnalyticsPreview } from "./model";
 import { t } from "../../../i18n";
 
-export function AccountTextField({
-  fieldKey,
-  label,
-  value,
-  placeholder,
-  activeField,
-  focused,
-  width,
-  type,
-  nodeRef,
-  onFocus,
-  onChange,
-  onSubmit,
-}: {
-  fieldKey: AccountFieldKey;
-  label: string;
-  value: string;
-  placeholder?: string;
-  activeField: AccountFieldKey;
-  focused: boolean;
-  width: number;
-  type?: "text" | "password";
-  /** The row, so the pane can scroll it into view. */
-  nodeRef?: Ref<BoxRenderable>;
-  onFocus: (field: AccountFieldKey) => void;
-  onChange: (value: string) => void;
-  onSubmit?: () => void;
-}) {
-  const active = activeField === fieldKey;
-  const labelWidth = accountFieldLabelWidth(width);
-  const inputWidth = Math.max(8, width - labelWidth - 1);
-  const labelText = useFieldLabel()(label, active);
-  return (
-    <Box
-      ref={nodeRef}
-      height={1}
-      width={width}
-      flexDirection="row"
-      alignItems="center"
-      gap={1}
-      onMouseDown={() => onFocus(fieldKey)}
-    >
-      <Text
-        width={labelWidth}
-        fg={active ? colors.textBright : colors.textDim}
-        attributes={active ? TextAttributes.BOLD : 0}
-      >
-        {truncate(labelText, labelWidth)}
-      </Text>
-      <TextField
-        value={value}
-        placeholder={placeholder}
-        focused={focused && active}
-        width={inputWidth}
-        type={type}
-        onChange={onChange}
-        onSubmit={onSubmit}
-        onMouseDown={() => onFocus(fieldKey)}
-      />
-    </Box>
-  );
-}
-
-/**
- * The desktop field draws its own focus ring, so its label is plain. The
- * terminal input only shows a cursor, so the active label keeps a marker.
- */
-export function useFieldLabel(): (label: string, active: boolean) => string {
-  const { nativePaneChrome } = useUiCapabilities();
-  return (label, active) => nativePaneChrome ? label : `${active ? "> " : "  "}${label}`;
-}
-
 export function accountFieldLabelWidth(width: number) {
   const preferred = width >= 28 ? 16 : Math.max(10, Math.floor(width * 0.42));
   return Math.max(8, Math.min(preferred, width - 9));
@@ -157,7 +85,6 @@ export function PublicAnalyticsGroup({
   onSelect: (value: string) => void;
 }) {
   const contentWidth = Math.max(1, width - 2);
-  const labelText = useFieldLabel()(t("Public Stats:"), active);
   const labelWidth = Math.min(accountFieldLabelWidth(width), Math.max(1, contentWidth));
   const buttonWidth = Math.max(8, Math.min(24, contentWidth - labelWidth - 1));
   const normalizedDetail = (detail ?? "").replace(/\.+$/, "");
@@ -178,9 +105,7 @@ export function PublicAnalyticsGroup({
       onMouseOver={onFocus}
     >
       <Box height={1} flexDirection="row" gap={1} alignItems="center">
-        <Text fg={active ? colors.textBright : colors.textDim} attributes={active ? TextAttributes.BOLD : 0}>
-          {truncate(labelText, labelWidth)}
-        </Text>
+        <FieldLabel label={t("Public Stats:")} active={active} maxWidth={labelWidth} />
         <SelectButton
           label={t("Public Stats")}
           value={value}
@@ -198,15 +123,15 @@ export function PublicAnalyticsGroup({
           const valueWidth = Math.max(1, metricWidth - labelTextWidth - 1);
           return (
             <Box key={metric.id} width={metricWidth} height={1} flexDirection="row" gap={1}>
-              <Text fg={colors.textDim}>{truncate(metric.label, labelTextWidth)}</Text>
+              <Text fg={colors.textDim}>{truncateWithEllipsis(metric.label, labelTextWidth)}</Text>
               <Text fg={metricColor(metric.tone)} attributes={TextAttributes.BOLD}>
-                {truncate(metric.value, valueWidth)}
+                {truncateWithEllipsis(metric.value, valueWidth)}
               </Text>
             </Box>
           );
         }) : detail ? (
           <Text fg={colors.textMuted}>
-            {truncate(detail, detailWidth)}
+            {truncateWithEllipsis(detail, detailWidth)}
           </Text>
         ) : null}
       </Box>

package/src/plugins/builtin/account-management/index.tsx

@@ -0,0 +1,26 @@
+import type { PluginModule } from "../plugin-module";
+import { AccountManagementPane } from "./pane";
+
+export const accountManagementModule: PluginModule = {
+  panes: [{
+    id: "account-management",
+    name: "ACM",
+    icon: "A",
+    component: AccountManagementPane,
+    defaultPosition: "right",
+    defaultMode: "floating",
+    defaultFloatingSize: { width: 72, height: 36 },
+    portableShare: {
+      private: { title: true, params: true, settings: true, state: true },
+    },
+  }],
+  paneTemplates: [{
+    id: "account-management-pane",
+    paneId: "account-management",
+    label: "Account Management",
+    description: "Edit your Gloom Cloud profile, password, and public portfolio sharing settings",
+    keywords: ["account", "profile", "cloud", "acm", "password", "settings"],
+    shortcut: { prefix: "ACM" },
+    createInstance: () => ({ placement: "floating" }),
+  }],
+};

package/src/plugins/builtin/account-management/keyboard.ts

@@ -1,10 +1,23 @@
+import type { RefObject } from "react";
+import { useFieldRing, type FieldRing } from "../../../components";
 import { useShortcut } from "../../../react/input";
+import type { ScrollBoxRenderable } from "../../../ui";
 import { isPlainKey } from "../../../utils/keyboard";
 import type { AccountDraft, AccountFieldKey } from "./model";
 
+const SCOPE = "account-management:fields";
+
+/** Checkboxes: Enter or Space flips them. */
+const TOGGLE_FIELDS = [
+  "profilePublic",
+  "acceptUnknownDms",
+  "weeklyRoundupEnabled",
+  "chatEmailNotificationsEnabled",
+  "positionAlertsEnabled",
+] as const satisfies readonly (AccountFieldKey & keyof AccountDraft)[];
+
 export function useAccountManagementKeyboard({
   activeField,
-  cycleField,
   cyclePortfolio,
   draftRef,
   fieldOrder,
@@ -13,12 +26,13 @@ export function useAccountManagementKeyboard({
   openPortfolioDialog,
   openUpgrade,
   saveProfile,
+  scrollRef,
+  setActiveField,
   setDraftValue,
   deleteAccount,
   turnOffEmailAlerts,
 }: {
   activeField: AccountFieldKey;
-  cycleField: (delta: number) => void;
   cyclePortfolio: (delta: number) => void;
   draftRef: { current: AccountDraft };
   /** The active tab's ring, in reading order. */
@@ -28,112 +42,50 @@ export function useAccountManagementKeyboard({
   openPortfolioDialog: () => Promise<void>;
   openUpgrade: () => void;
   saveProfile: () => Promise<void>;
+  scrollRef: RefObject<ScrollBoxRenderable | null>;
+  setActiveField: (field: AccountFieldKey) => void;
   setDraftValue: <K extends keyof AccountDraft>(key: K, value: AccountDraft[K]) => void;
   deleteAccount: () => Promise<void>;
   turnOffEmailAlerts: () => Promise<void>;
-}) {
+}): FieldRing<AccountFieldKey> {
+  const actions: Partial<Record<AccountFieldKey, () => void>> = {
+    sharedPortfolioId: () => { void openPortfolioDialog(); },
+    passwordAction: openPasswordDialog,
+    upgradeAction: openUpgrade,
+    deleteAccountAction: () => { void deleteAccount(); },
+    emailAlertsOffAction: () => { void turnOffEmailAlerts(); },
+  };
+  for (const key of TOGGLE_FIELDS) actions[key] = () => setDraftValue(key, !draftRef.current[key]);
+
+  const ring = useFieldRing({
+    ids: fieldOrder,
+    activeId: activeField,
+    onActivate: setActiveField,
+    enabled: focused,
+    scope: SCOPE,
+    actions,
+    scrollRef,
+  });
+
   useShortcut((event) => {
-    if (event.ctrl && event.name === "s") {
+    const consume = () => {
       event.preventDefault?.();
       event.stopPropagation?.();
+    };
+    if (event.ctrl && event.name === "s") {
+      consume();
       void saveProfile();
       return;
     }
-
-    if (event.name === "tab" && !event.ctrl && !event.meta && !event.alt) {
-      // Tab and Shift+Tab walk the fields; past either end they move on to the
-      // next pane like everywhere else, so the pane never traps the keyboard.
-      const index = fieldOrder.indexOf(activeField);
-      const next = event.shift ? (index > 0 ? fieldOrder[index - 1] : undefined) : fieldOrder[index + 1];
-      if (!next) return;
-      event.preventDefault?.();
-      event.stopPropagation?.();
-      cycleField(event.shift ? -1 : 1);
-      return;
-    }
-    if (!event.targetEditable && isPlainKey(event, "down", "j")) {
-      event.preventDefault?.();
-      event.stopPropagation?.();
-      cycleField(1);
-      return;
-    }
-    if (!event.targetEditable && isPlainKey(event, "up", "k")) {
-      event.preventDefault?.();
-      event.stopPropagation?.();
-      cycleField(-1);
-      return;
-    }
-    if (!event.targetEditable && activeField === "profilePublic" && isPlainKey(event, "space", "enter", "return")) {
-      event.preventDefault?.();
-      event.stopPropagation?.();
-      setDraftValue("profilePublic", !draftRef.current.profilePublic);
-      return;
-    }
-    if (!event.targetEditable && activeField === "acceptUnknownDms" && isPlainKey(event, "space", "enter", "return")) {
-      event.preventDefault?.();
-      event.stopPropagation?.();
-      setDraftValue("acceptUnknownDms", !draftRef.current.acceptUnknownDms);
-      return;
-    }
-    if (!event.targetEditable && activeField === "weeklyRoundupEnabled" && isPlainKey(event, "space", "enter", "return")) {
-      event.preventDefault?.();
-      event.stopPropagation?.();
-      setDraftValue("weeklyRoundupEnabled", !draftRef.current.weeklyRoundupEnabled);
-      return;
-    }
-    if (!event.targetEditable && activeField === "chatEmailNotificationsEnabled" && isPlainKey(event, "space", "enter", "return")) {
-      event.preventDefault?.();
-      event.stopPropagation?.();
-      setDraftValue("chatEmailNotificationsEnabled", !draftRef.current.chatEmailNotificationsEnabled);
-      return;
-    }
-    if (!event.targetEditable && activeField === "positionAlertsEnabled" && isPlainKey(event, "space", "enter", "return")) {
-      event.preventDefault?.();
-      event.stopPropagation?.();
-      setDraftValue("positionAlertsEnabled", !draftRef.current.positionAlertsEnabled);
-      return;
-    }
-    if (!event.targetEditable && activeField === "sharedPortfolioId" && isPlainKey(event, "left", "h", "[")) {
-      event.preventDefault?.();
-      event.stopPropagation?.();
+    if (event.targetEditable || activeField !== "sharedPortfolioId") return;
+    if (isPlainKey(event, "left", "h", "[")) {
+      consume();
       cyclePortfolio(-1);
-      return;
-    }
-    if (!event.targetEditable && activeField === "sharedPortfolioId" && isPlainKey(event, "right", "l", "]")) {
-      event.preventDefault?.();
-      event.stopPropagation?.();
+    } else if (isPlainKey(event, "right", "l", "]")) {
+      consume();
       cyclePortfolio(1);
-      return;
-    }
-    if (!event.targetEditable && activeField === "sharedPortfolioId" && isPlainKey(event, "space", "enter", "return")) {
-      event.preventDefault?.();
-      event.stopPropagation?.();
-      void openPortfolioDialog();
-      return;
     }
-    if (!event.targetEditable && activeField === "passwordAction" && isPlainKey(event, "space", "enter", "return")) {
-      event.preventDefault?.();
-      event.stopPropagation?.();
-      openPasswordDialog();
-      return;
-    }
-    if (!event.targetEditable && activeField === "upgradeAction" && isPlainKey(event, "space", "enter", "return")) {
-      event.preventDefault?.();
-      event.stopPropagation?.();
-      openUpgrade();
-      return;
-    }
-    if (!event.targetEditable && activeField === "deleteAccountAction" && isPlainKey(event, "space", "enter", "return")) {
-      event.preventDefault?.();
-      event.stopPropagation?.();
-      void deleteAccount();
-      return;
-    }
-    if (!event.targetEditable && activeField === "emailAlertsOffAction" && isPlainKey(event, "space", "enter", "return")) {
-      event.preventDefault?.();
-      event.stopPropagation?.();
-      void turnOffEmailAlerts();
-    }
-    // Scoped in "before", so the fields see Tab ahead of the app's pane cycling.
-  }, { allowEditable: true, phase: "before", scope: "account-management:fields", enabled: focused });
+  }, { allowEditable: true, phase: "before", scope: SCOPE, enabled: focused });
+
+  return ring;
 }