gloomberb 0.17.3 → 0.17.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gloomberb",
-  "version": "0.17.3",
+  "version": "0.17.4",
   "packageManager": "bun@1.3.11",
   "description": "Market research and portfolio tracker for the terminal",
   "module": "src/public/index.ts",
@@ -86,6 +86,7 @@
     "check:pane-screenshot": "bun run scripts/pane-chrome/screenshot.ts",
     "check:pane-rest": "bun run scripts/pane-chrome/rest-diff.ts",
     "check:pane-layout": "bun run scripts/pane-chrome/layout-sweep.ts",
+    "audit:ui": "bun run scripts/pane-chrome/ui-audit.ts",
     "benchmark:pane-drag:compare": "bun run scripts/pane-chrome/frame-budget.ts",
     "test:global-upgrade": "bun run scripts/smoke-global-upgrade.ts",
     "release": "./scripts/release.sh"

package/src/api-client/chat.ts

@@ -154,16 +154,40 @@ export class CloudChatApi {
     );
   }
 
+  /**
+   * `seen`: the app showed them where the reader was looking (the open
+   * channel, a toast in the foreground), which also cancels the phone push
+   * waiting on them. A server that predates it ignores the field.
+   */
   async markNotificationsDelivered(
     notificationIds: string[],
+    options: { seen?: boolean } = {},
   ): Promise<{ delivered: number }> {
     return this.request<{ delivered: number }>(
       "/chat/notifications/delivered",
+      {
+        method: "POST",
+        body: JSON.stringify({ notificationIds, ...(options.seen ? { seen: true } : {}) }),
+      },
+    );
+  }
+
+  /**
+   * The notifications among these the reader has neither read nor been shown
+   * in front of them, on any device. Throws on a server without the route
+   * (404); the caller raises the alert then, as before.
+   */
+  async getUnseenNotificationIds(notificationIds: string[]): Promise<string[]> {
+    const answer = await this.request<{ notificationIds?: unknown }>(
+      "/chat/notifications/unseen",
       {
         method: "POST",
         body: JSON.stringify({ notificationIds }),
       },
     );
+    return Array.isArray(answer?.notificationIds)
+      ? answer.notificationIds.filter((id): id is string => typeof id === "string")
+      : notificationIds;
   }
 
   async openDirectChannel(target: {
@@ -327,6 +351,10 @@ export class CloudChatApi {
     return this.options.socket.subscribeChatNotifications(listener);
   }
 
+  subscribeChannelState(listener: (state: ChatChannelState) => void): () => void {
+    return this.options.socket.subscribeChatChannelState(listener);
+  }
+
   subscribePresence(listener: ChatPresenceListener): () => void {
     return this.options.socket.subscribeChatPresence(listener);
   }

package/src/api-client/errors.ts

@@ -75,12 +75,22 @@ export function parseApiErrorMessage(body: string): string {
       (value): value is string =>
         typeof value === "string" && value.trim().length > 0,
     );
-    return parts.join(" ") || body;
+    return parts.join(" ") || validationErrorText(parsed) || body;
   } catch {
     return htmlErrorTitle(body) ?? body;
   }
 }
 
+/**
+ * A request the API's schema refused comes back as the values it was sent
+ * (`{"type":"validation","on":"query","found":{...}}`), which is no message to
+ * show; it is said in words instead.
+ */
+function validationErrorText(parsed: Record<string, unknown>): string | null {
+  if (parsed.type !== "validation") return null;
+  return parsed.on === "query" ? "Gloom Cloud did not accept an option or filter value." : "Gloom Cloud did not accept the request.";
+}
+
 /** A JSON error body as an object, or undefined for any other body. */
 export function parseApiErrorDetails(body: string): Readonly<Record<string, unknown>> | undefined {
   try {

package/src/api-client/index.ts

@@ -60,7 +60,8 @@ export type {
 /** Server-side caps for `/assist/command`; enforced here so a 422 is never sent. */
 const ASSIST_QUERY_MAX_LENGTH = 200;
 const ASSIST_COMMAND_LIMIT = 150;
-const ASSIST_ARG_OPTION_LIMIT = 64;
+/** The futures curve's root list is the longest a command sends: 76 since GLO-783. */
+export const ASSIST_ARG_OPTION_LIMIT = 128;
 const ASSIST_ARG_OPTION_VALUE_MAX_LENGTH = 40;
 const ASSIST_ARG_OPTION_LABEL_MAX_LENGTH = 60;
 const ASSIST_REQUEST_TIMEOUT_MS = 6_000;
@@ -646,6 +647,7 @@ class GloomApiClient {
   getChatState = this.chat.getState.bind(this.chat);
   updateChatChannelState = this.chat.updateChannelState.bind(this.chat);
   markChatNotificationsDelivered = this.chat.markNotificationsDelivered.bind(this.chat);
+  getUnseenChatNotificationIds = this.chat.getUnseenNotificationIds.bind(this.chat);
   openDirectChannel = this.chat.openDirectChannel.bind(this.chat);
   openGroupChannel = this.chat.openGroupChannel.bind(this.chat);
   getMessages = this.chat.getMessages.bind(this.chat);
@@ -658,6 +660,7 @@ class GloomApiClient {
   subscribeChatReactions = this.chat.subscribeReactions.bind(this.chat);
   connectChannel = this.chat.connectChannel.bind(this.chat);
   subscribeChatNotifications = this.chat.subscribeNotifications.bind(this.chat);
+  subscribeChatChannelState = this.chat.subscribeChannelState.bind(this.chat);
   subscribeChatPresence = this.chat.subscribePresence.bind(this.chat);
   getChatDiscordLink = this.chat.getDiscordLink.bind(this.chat);
   unlinkChatDiscord = this.chat.unlinkDiscord.bind(this.chat);

package/src/api-client/normalizers.ts

@@ -2,6 +2,7 @@ import type {
   ChatAccountType,
   ChatAttachment,
   ChatChannel,
+  ChatChannelState,
   ChatDiscordLink,
   ChatMessage,
   ChatMessageOrigin,
@@ -191,6 +192,26 @@ export function normalizeChatNotification(
   };
 }
 
+/** A `chat.channel_state` frame, or null when it is not one. */
+export function normalizeChatChannelStateFrame(data: unknown): ChatChannelState | null {
+  if (!data || typeof data !== "object") return null;
+  const state = data as Partial<ChatChannelState>;
+  if (
+    typeof state.channelId !== "string"
+    || typeof state.notificationsEnabled !== "boolean"
+    || typeof state.unreadCount !== "number"
+    || (state.lastReadMessageId !== null && typeof state.lastReadMessageId !== "string")
+  ) {
+    return null;
+  }
+  return {
+    channelId: state.channelId,
+    notificationsEnabled: state.notificationsEnabled,
+    lastReadMessageId: state.lastReadMessageId,
+    unreadCount: state.unreadCount,
+  };
+}
+
 export function normalizeChatChannel(
   channel: ChatChannel,
   fallbackKind: ChatChannel["kind"] = "public",

package/src/api-client/socket.ts

@@ -1,6 +1,7 @@
 import type { TapeFeedEvent } from "./tape";
 import type {
   AuthUser,
+  ChatChannelState,
   ChatMessage,
   ChatNotification,
   ChatReactionsUpdate,
@@ -11,6 +12,7 @@ import type {
   TeamNotification,
 } from "./types";
 import {
+  normalizeChatChannelStateFrame,
   normalizeChatMessage,
   normalizeChatNotification,
   normalizeChatReactions,
@@ -42,6 +44,7 @@ const cloudApiLog = debugLog.createLogger("cloud-api");
 
 type ChannelListener = (message: ChatMessage) => void;
 type ChatNotificationListener = (notification: ChatNotification) => void;
+type ChatChannelStateListener = (state: ChatChannelState) => void;
 type ChatPresenceListener = (onlineCount: number) => void;
 type ChatReactionsListener = (update: ChatReactionsUpdate) => void;
 type TeamNotificationListener = (notification: TeamNotification) => void;
@@ -108,6 +111,8 @@ export class CloudApiSocket {
   private readonly channelListeners = new Map<string, Set<ChannelListener>>();
   private readonly chatNotificationListeners =
     new Set<ChatNotificationListener>();
+  private readonly chatChannelStateListeners =
+    new Set<ChatChannelStateListener>();
   private readonly chatPresenceListeners = new Set<ChatPresenceListener>();
   private readonly chatReactionsListeners = new Set<ChatReactionsListener>();
   private readonly teamNotificationListeners =
@@ -249,6 +254,17 @@ export class CloudApiSocket {
     };
   }
 
+  /**
+   * The reader's read state or mute changed on another device or window. Like
+   * notifications, it never opens the socket by itself.
+   */
+  subscribeChatChannelState(listener: ChatChannelStateListener): () => void {
+    this.chatChannelStateListeners.add(listener);
+    return () => {
+      this.chatChannelStateListeners.delete(listener);
+    };
+  }
+
   /** A message's reactions changed in a channel this socket reads. */
   subscribeChatReactions(listener: ChatReactionsListener): () => void {
     this.chatReactionsListeners.add(listener);
@@ -511,6 +527,7 @@ export class CloudApiSocket {
     this.offeredFeatureListeners.clear();
     this.connectionListeners.clear();
     this.chatNotificationListeners.clear();
+    this.chatChannelStateListeners.clear();
     this.chatPresenceListeners.clear();
     this.chatReactionsListeners.clear();
     this.teamNotificationListeners.clear();
@@ -614,6 +631,16 @@ export class CloudApiSocket {
       return;
     }
 
+    if (parsed?.type === "chat.channel_state") {
+      const state = normalizeChatChannelStateFrame(parsed.data);
+      if (state) {
+        for (const listener of this.chatChannelStateListeners) {
+          listener(state);
+        }
+      }
+      return;
+    }
+
     if (parsed?.type === "team.notification" && parsed.data) {
       const notification = normalizeTeamNotification(
         parsed.data as TeamNotification,

package/src/app/runtime/startup.ts

@@ -107,6 +107,10 @@ export function useAppStartupRuntime({
     appLog.info("app activity propagated", { active: appActive });
   }, [appActive]);
 
+  useEffect(() => {
+    chatController.setRaisesBackgroundAlerts(!isDetachedWindow);
+  }, [isDetachedWindow]);
+
   // Runs for the life of the app: a freeze is only reportable if something
   // was watching the clock while it happened.
   useEffect(() => startMainThreadStallMonitor(), []);

package/src/cli/pane-functions/function-help.ts

@@ -749,7 +749,7 @@ export const FUNCTION_HELP: Readonly<Record<string, FunctionHelp>> = {
     bloomberg: [],
   },
   FUT: {
-    summary: "Each root's most active futures contract across equity index, rates, energy, metals, agriculture, livestock and FX with last price, unit and session change, grouped by sector.",
+    summary: "Each root's most active futures contract across equity index, equity sectors, rates, energy, metals, agriculture, livestock and FX with last price, unit and session change, grouped by sector.",
     usage: ["FUT"],
     keys: [SEARCH, OPEN],
     data: same(DELAYED),

package/src/components/index.ts

@@ -147,7 +147,7 @@ export type {
   NoticeProps, NumberFieldProps, PaneStatusBodyProps, PopoverProps, ProseProps, QueryBarFilter,
   QueryBarMultiFilter, QueryBarProps, QueryBarSearch, QueryBarSearchFocus, QueryBarSelectFilter, QueryBarTextFilter,
   QueryBarToggleFilter, QueryBarView, RangeTrackProps, RatioBarProps, SectionHeadingProps, SectionProps, SegmentedControlProps,
-  SelectButtonOption, SelectButtonProps, SelectControl, StatGridProps, StatItem, TabsProps,
+  SelectButtonOption, SelectButtonProps, SelectControl, StatGridProps, StatItem, StatusRetry, TabsProps,
   TextFieldProps, TextPromptDialogProps,
 } from "./ui";
 export { usePaneTicker } from "../state/app/context";

package/src/components/metric-treemap/heat-surface.tsx

@@ -1,6 +1,7 @@
 import { memo, useEffect, useMemo, useRef, useState, type CSSProperties } from "react";
 import { Box, Text, TextAttributes, useUiCapabilities, type BoxRenderable } from "../../ui";
 import { useLiveStretch } from "../../ui/live-stretch";
+import { useSettledLayoutSize } from "../../ui/resize-settle";
 import { blendHex } from "../../theme/colors";
 import {
   heatmapColorDistance,
@@ -91,9 +92,57 @@ export function buildHeatTreemapScene<T>(
   return buildMetricTreemapScene(items, canvas.width, canvas.height, canvas.options, previous);
 }
 
+export interface HeatTreemapLayout<T> {
+  scene: MetricTreemapScene<T>;
+  /** The box is being resized (`useSettledLayoutSize`): hand it to the surface, which then holds still. */
+  resizing: boolean;
+}
+
+interface ShownScene<T> {
+  key: string;
+  canvas: HeatTreemapCanvas;
+  items: readonly MetricTreemapItem<T>[];
+  scene: MetricTreemapScene<T>;
+}
+
+/**
+ * The scene a heat map shows in a `width` by `height` box (cells). Each
+ * layout is seeded with the scene on screen under the same `key` (a tab), so
+ * a refresh nudges tiles instead of reshuffling the board. On the desktop,
+ * while the box is being resized the scene on screen stretches with it and a
+ * refresh's new sizes wait: the board is laid out once, at the size the box
+ * settles on.
+ */
+export function useHeatTreemapScene<T>(
+  items: readonly MetricTreemapItem<T>[],
+  width: number,
+  height: number,
+  key = "",
+): HeatTreemapLayout<T> {
+  const { nativePaneChrome, cellWidthPx, cellHeightPx } = useUiCapabilities();
+  const layout = useSettledLayoutSize(width, height, { enabled: nativePaneChrome === true });
+  const canvas = useMemo(
+    () => heatTreemapCanvas(layout.width, layout.height, { nativePaneChrome, cellWidthPx, cellHeightPx }),
+    [cellHeightPx, cellWidthPx, layout.height, layout.width, nativePaneChrome],
+  );
+  const shownRef = useRef<ShownScene<T> | null>(null);
+  const scene = useMemo(() => {
+    const shown = shownRef.current?.key === key ? shownRef.current : null;
+    // While the box resizes, the scene on screen holds until it is laid out
+    // again, a refresh's new sizes with it: the board relays out once.
+    if (shown && shown.canvas === canvas && (layout.resizing || shown.items === items)) return shown.scene;
+    const next = buildHeatTreemapScene(items, canvas, shown?.scene);
+    shownRef.current = { key, canvas, items, scene: next };
+    return next;
+  }, [canvas, items, key, layout.resizing]);
+  return { scene, resizing: layout.resizing };
+}
+
 export interface HeatTreemapSurfaceProps<T> {
-  /** Geometry, from `buildHeatTreemapScene`; rebuilt only when sizes change. */
+  /** Geometry, from `useHeatTreemapScene`; rebuilt only when sizes change. */
   scene: MetricTreemapScene<T>;
+  /** From `useHeatTreemapScene`: while the box resizes, no tile glides, fades or pulses. */
+  resizing: boolean;
   /** Current colours and text, by id; they change with every tick. */
   items: readonly MetricTreemapItem<T>[];
   width: number;
@@ -223,7 +272,7 @@ const VERTICAL_LABEL_STYLE: CSSProperties = {
 
 const DomHeatTile = memo(function DomHeatTile({
   id, rect, canvasWidth, canvasHeight, gap, label, value, valueSuffix, background, foreground,
-  selected, reducedMotion, glide, pulseCount, events,
+  selected, reducedMotion, resizing, glide, pulseCount, events,
 }: {
   id: string;
   rect: TreemapRect;
@@ -237,6 +286,8 @@ const DomHeatTile = memo(function DomHeatTile({
   foreground: string;
   selected: boolean;
   reducedMotion: boolean;
+  resizing: boolean;
+  /** A relayout this render may slide the tile: false for one that came with a new size. */
   glide: boolean;
   pulseCount: number;
   events: SurfaceEvents;
@@ -248,16 +299,22 @@ const DomHeatTile = memo(function DomHeatTile({
   });
   // Where this tile sat before the last relayout, kept to slide it from there.
   const placedRef = useRef(rect);
-  const glideRef = useRef<{ dx: number; dy: number; count: number }>({ dx: 0, dy: 0, count: 0 });
+  const glideRef = useRef<{ dx: number; dy: number; count: number; playing: boolean }>({ dx: 0, dy: 0, count: 0, playing: false });
+  const allowGlide = glide && !resizing;
   if (placedRef.current !== rect) {
     const dx = placedRef.current.x - rect.x;
     const dy = placedRef.current.y - rect.y;
-    if (glide && (Math.abs(dx) >= 0.5 || Math.abs(dy) >= 0.5)) {
-      glideRef.current = { dx, dy, count: glideRef.current.count + 1 };
-    }
+    // A slide belongs to the relayout that moved the tile: a later render
+    // (a tick, a hover, the end of a resize) never plays it again.
+    glideRef.current = allowGlide && (Math.abs(dx) >= 0.5 || Math.abs(dy) >= 0.5)
+      ? { dx, dy, count: glideRef.current.count + 1, playing: true }
+      : { ...glideRef.current, playing: false };
     placedRef.current = rect;
+  } else if (resizing && glideRef.current.playing) {
+    // A resize stops a slide under way: the tile sits where its layout has it.
+    glideRef.current = { ...glideRef.current, playing: false };
   }
-  const motion = heatTileMotion({ reducedMotion, glide, glideCount: glideRef.current.count, pulseCount });
+  const motion = heatTileMotion({ reducedMotion, resizing, glide: glideRef.current.playing, glideCount: glideRef.current.count, pulseCount });
   const colors = useThemeColors();
   const ring = resolveHeatmapSelectionRing(colors);
   // The colour this tile showed before, kept to fade out over the new one.
@@ -274,10 +331,13 @@ const DomHeatTile = memo(function DomHeatTile({
     else if (visible) fadeRef.current = { from: shownRef.current, key: (fadeRef.current?.key ?? 0) + 1 };
     shownRef.current = background;
   }
+  // A resize ends a fade under way, and the pulses due meanwhile are dropped, not saved for later.
+  if (resizing) fadeRef.current = null;
   const fade = fadeRef.current;
   // A finished overlay leaves the DOM, so idle tiles carry no extra nodes.
   const [, setOverlayVersion] = useState(0);
   const pulseDoneRef = useRef(0);
+  if (resizing) pulseDoneRef.current = Math.max(pulseDoneRef.current, pulseCount);
   const pulsing = motion.pulseAnimation != null && pulseCount > pulseDoneRef.current;
   const style: CSSProperties = {
     position: "absolute",
@@ -491,7 +551,7 @@ function DomTooltip<T>({ state, itemsById, otherLines }: {
 const EMPTY_PULSES: ReadonlyMap<string, number> = new Map();
 
 function DomHeatTreemap<T>({
-  scene, items, width, height, selectedId, onSelect, onActivate, otherTooltip, otherSummary: summarizeOther,
+  scene, resizing, items, width, height, selectedId, onSelect, onActivate, otherTooltip, otherSummary: summarizeOther,
 }: HeatTreemapSurfaceProps<T>) {
   const reducedMotion = usePrefersReducedMotion();
   const colors = useThemeColors();
@@ -519,13 +579,14 @@ function DomHeatTreemap<T>({
     );
   }, [itemsById, reducedMotion, scene]);
 
-  // A resize relays out every tile; following the window with a glide would lag it.
+  // The layout a resize settles on comes in at once, as a chart or a table
+  // redraws at its new size: tiles slide only when sizes move at rest.
   const sizeKey = `${scene.width}x${scene.height}`;
-  const lastSizeRef = useRef(sizeKey);
-  const glide = lastSizeRef.current === sizeKey;
+  const restedRef = useRef({ sizeKey, resizing });
+  const glide = !resizing && !restedRef.current.resizing && restedRef.current.sizeKey === sizeKey;
   useEffect(() => {
-    lastSizeRef.current = sizeKey;
-  }, [sizeKey]);
+    restedRef.current = { sizeKey, resizing };
+  }, [resizing, sizeKey]);
 
   const gap = scene.width < NARROW_CANVAS_PX ? 0.5 : 1;
   const otherLines = useMemo(
@@ -603,6 +664,7 @@ function DomHeatTreemap<T>({
               foreground={tileColors.foreground}
               selected={tile.item.id === selectedId}
               reducedMotion={reducedMotion}
+              resizing={resizing}
               glide={glide}
               pulseCount={pulses.get(tile.item.id) ?? 0}
               events={events}
@@ -755,7 +817,7 @@ function TerminalHeatTreemap<T>({
  * calm tiles (ticker, then the move, as space allows), a continuous scale
  * from the theme's down colour to its up colour, and on the desktop a hover
  * tooltip, colour fades, a short pulse on a tile whose move jumps and a glide
- * when sizes change.
+ * when sizes change, none of them while the box is being resized.
  */
 export function HeatTreemapSurface<T>(props: HeatTreemapSurfaceProps<T>) {
   const { nativePaneChrome } = useUiCapabilities();

package/src/components/metric-treemap/heat-tiles.ts

@@ -240,15 +240,17 @@ export interface HeatTileMotion {
  * tile from its old place (its new size applies at once), a colour change
  * fades the old colour out over the new one, and a jump in the move flashes
  * once. `glideCount` alternates two keyframe names, which restarts the slide.
- * Reduced motion keeps every change instant.
+ * Reduced motion keeps every change instant, and so does a resize: while the
+ * box is changing size nothing on the board moves on its own.
  */
-export function heatTileMotion({ reducedMotion, glide, glideCount, pulseCount }: {
+export function heatTileMotion({ reducedMotion, resizing, glide, glideCount, pulseCount }: {
   reducedMotion: boolean;
+  resizing: boolean;
   glide: boolean;
   glideCount: number;
   pulseCount: number;
 }): HeatTileMotion {
-  if (reducedMotion) return {};
+  if (reducedMotion || resizing) return {};
   return {
     ...(glide && glideCount > 0
       ? { glideAnimation: `gloom-heat-glide-${glideCount % 2 === 0 ? "b" : "a"} ${GLIDE_MS}ms ease` }

package/src/components/metric-treemap/index.tsx

@@ -18,7 +18,7 @@ export {
   type MetricTreemapDirection,
   type MetricTreemapItem,
 } from "./layout";
-export { buildHeatTreemapScene, heatTreemapCanvas, HeatTreemapSurface } from "./heat-surface";
+export { buildHeatTreemapScene, heatTreemapCanvas, HeatTreemapSurface, useHeatTreemapScene } from "./heat-surface";
 export { formatHeatTileMove, settleTreemapLayoutItems } from "./heat-tiles";
 
 type PreventableMouseEvent = { preventDefault(): void };

package/src/components/ui/button.tsx

@@ -26,6 +26,14 @@ export interface ButtonProps {
   onPress?: () => void;
   variant?: ButtonVariant;
   disabled?: boolean;
+  /**
+   * The action it started is still running (a retry waiting for its answer).
+   * It reads as disabled and ignores presses, but keeps its key, so it does not
+   * change size and the key does not fall through to something else.
+   */
+  pending?: boolean;
+  /** What it says while pending, such as "Retrying...". Without it the label stays. */
+  pendingLabel?: string;
   active?: boolean;
   shortcut?: string;
   /**
@@ -86,9 +94,11 @@ export function Button({
   displayLabel,
   children,
   expanded,
-  onPress,
+  onPress: pressAction,
   variant = "secondary",
   disabled = false,
+  pending = false,
+  pendingLabel,
   active = false,
   shortcut,
   desktopShortcut,
@@ -100,17 +110,21 @@ export function Button({
   title,
 }: ButtonProps) {
   const colors = useThemeColors();
-  const label = t(rawLabel);
+  const label = t(pending && pendingLabel ? pendingLabel : rawLabel);
+  if (pending && pendingLabel) displayLabel = undefined;
+  // A pending press is ignored, but the button stays its scope's primary action.
+  const onPress = pressAction && pending ? () => {} : pressAction;
   const scopedShortcut = useScopedButtonAction(label, onPress, disabled);
   shortcut = shortcut ?? scopedShortcut;
+  const inert = disabled || pending;
   const remoteScope = useRemoteUiScope();
   useRemoteUiNode({
     role: "button",
     label,
-    disabled,
+    disabled: inert,
     actions: {
       press: () => {
-        if (!disabled) onPress?.();
+        if (!inert) onPress?.();
       },
     },
     metadata: { variant, active, shortcut, expanded, ...(remoteScope ? { scope: remoteScope } : {}) },
@@ -124,7 +138,8 @@ export function Button({
         expanded={expanded}
         onPress={onPress}
         variant={variant}
-        disabled={disabled}
+        disabled={inert}
+        pending={pending}
         active={active}
         shortcut={shortcut ?? desktopShortcut}
         title={title}
@@ -137,7 +152,7 @@ export function Button({
     );
   }
 
-  const palette = resolveButtonColors(variant, active, disabled, colors);
+  const palette = resolveButtonColors(variant, active, inert, colors);
 
   return (
     <Box
@@ -145,20 +160,20 @@ export function Button({
       height={height ?? 1}
       flexDirection="row"
       backgroundColor={palette.bg}
-      cursor={disabled ? "default" : "pointer"}
+      cursor={inert ? "default" : "pointer"}
       onMouseDown={(event: { preventDefault?: () => void; stopPropagation?: () => void }) => {
         if (stopPropagation) {
           event.preventDefault?.();
           event.stopPropagation?.();
         }
-        if (!disabled) onPress?.();
+        if (!inert) onPress?.();
       }}
     >
       {children ?? <Text fg={palette.fg} attributes={active ? TextAttributes.BOLD : 0}>
         {compact ? displayLabel ?? label : ` ${displayLabel ?? label} `}
       </Text>}
       {shortcut && (
-        <Text fg={disabled ? colors.textMuted : colors.textDim}>
+        <Text fg={inert ? colors.textMuted : colors.textDim}>
           {` ${shortcut}`}
         </Text>
       )}

package/src/components/ui/index.ts

@@ -60,7 +60,7 @@ export type { TabsProps } from "./tabs";
 export { SegmentedControl } from "./toggle";
 export type { SegmentedControlProps } from "./toggle";
 export { EmptyState, PaneStatusBody, Notice, loadingText, unavailableText } from "./status";
-export type { EmptyStateProps, PaneStatusBodyProps, NoticeProps } from "./status";
+export type { EmptyStateProps, PaneStatusBodyProps, NoticeProps, StatusRetry } from "./status";
 export { Badge, BulletList, Divider, FigureList, KeyValueRow, Prose, READING_WIDTH, Section, SectionHeading } from "./display";
 export type {
   BadgeProps, BulletListProps, DividerProps, FigureListItem, FigureListProps, KeyValueRowProps, ProseProps, SectionProps,