gloomberb 0.10.0 → 0.10.2

package/src/plugins/builtin/chart-composer/index.tsx

@@ -217,12 +217,6 @@ export const chartComposerModule: PluginModule = {
   },
 };
 
-export { CHART_COMPOSER_PANE_ID } from "../../../types/config";
-export { ChartComposerPane, ChartComposerResearchTab, ChartComposerSurface } from "./pane";
-export { DateWindowDialog } from "./date-window-dialog";
-export { SeriesEditorDialog } from "./editor";
 export * from "./chart-spec";
 export * from "./presets";
 export * from "./settings";
-
-export default chartComposerModule;

package/src/plugins/builtin/chart-composer/pane.tsx

@@ -41,6 +41,7 @@ import {
   buildPriceChartPreset,
   applySeriesStyle,
   chartSeriesLabel,
+  defaultFinancialTimestampMode,
   getSelectedBuiltinStudies,
   getSelectedPairStudies,
   setBuiltinStudies,
@@ -66,7 +67,12 @@ const RESOLUTION_TABS_WIDTH = RESOLUTION_TABS.reduce(
   (width, tab) => width + [...tab.label].length + 1,
   0,
 );
-const AUTO_VIEWPORT_DEBOUNCE_MS = 120;
+const AUTO_VIEWPORT_DEBOUNCE_MS = 350;
+
+interface RuntimeChartViewport {
+  start: Date;
+  end: Date;
+}
 
 function footerAnchorPoint(event?: PaneFooterPressEvent): { x: number; y: number } | undefined {
   const x = event?.pixelX;
@@ -76,7 +82,7 @@ function footerAnchorPoint(event?: PaneFooterPressEvent): { x: number; y: number
     : undefined;
 }
 
-export interface ChartComposerSurfaceProps {
+interface ChartComposerSurfaceProps {
   spec: ChartSpec;
   setSpec: (next: ChartSpec) => void;
   focused: boolean;
@@ -93,7 +99,7 @@ function isPriceStudyTarget(spec: ChartSpec): boolean {
   ));
 }
 
-export function ChartComposerSurface({
+function ChartComposerSurface({
   spec,
   setSpec,
   focused,
@@ -110,6 +116,7 @@ export function ChartComposerSurface({
     range: spec.viewport.range,
     resolution: spec.viewport.resolution,
     dateWindow: spec.viewport.dateWindow ?? null,
+    maxPoints: spec.viewport.maxPoints ?? null,
     sources: spec.series.map((entry) => entry.source.kind === "security"
       ? [
           entry.id,
@@ -118,20 +125,31 @@ export function ChartComposerSurface({
           entry.source.instrument.exchange ?? "",
           entry.source.fieldId,
           entry.source.period ?? "auto",
+          entry.source.timestampMode
+            ?? defaultFinancialTimestampMode(entry.source.fieldId)
+            ?? "",
         ]
       : [entry.id, entry.source.kind, entry.source.seriesId]),
-  }), [spec.series, spec.viewport.dateWindow, spec.viewport.range, spec.viewport.resolution]);
-  const [autoViewportState, setAutoViewportState] = useState<{
+  }), [spec.series, spec.viewport.dateWindow, spec.viewport.maxPoints, spec.viewport.range, spec.viewport.resolution]);
+  const [runtimeViewportState, setRuntimeViewportState] = useState<{
     key: string;
-    viewport: { start: Date; end: Date };
+    adaptiveViewport: RuntimeChartViewport | null;
+    requestViewport: RuntimeChartViewport;
   } | null>(null);
-  const autoViewportTimerRef = useRef<ReturnType<typeof globalThis.setTimeout> | null>(null);
-  const autoViewport = autoViewportState?.key === authoredViewportKey
-    && spec.viewport.resolution === "auto"
-    ? autoViewportState.viewport
+  const runtimeViewportTimerRef = useRef<ReturnType<typeof globalThis.setTimeout> | null>(null);
+  const adaptiveViewportRef = useRef<RuntimeChartViewport | null>(null);
+  const requestViewportRef = useRef<RuntimeChartViewport | null>(null);
+  const activeRuntimeViewport = runtimeViewportState?.key === authoredViewportKey
+    ? runtimeViewportState
     : null;
   const targetPointCount = Math.max(60, Math.floor(width * 1.25));
-  const resolution = useResolvedChartSpec(spec, { autoViewport, targetPointCount });
+  const resolution = useResolvedChartSpec(spec, {
+    autoViewport: spec.viewport.resolution === "auto"
+      ? activeRuntimeViewport?.adaptiveViewport
+      : null,
+    requestViewport: activeRuntimeViewport?.requestViewport,
+    targetPointCount,
+  });
   const selectedStudies = getSelectedBuiltinStudies(spec);
   const selectedPairStudies = getSelectedPairStudies(spec);
   const inlineStyleTarget = useMemo(() => getChartInlineStyleTarget(spec), [spec]);
@@ -184,42 +202,55 @@ export function ChartComposerSurface({
     if (!focused) dispatch({ type: "FOCUS_PANE", paneId });
   }, [dispatch, focused, paneId]);
   useEffect(() => {
-    if (autoViewportTimerRef.current !== null) {
-      clearTimeout(autoViewportTimerRef.current);
-      autoViewportTimerRef.current = null;
+    if (runtimeViewportTimerRef.current !== null) {
+      clearTimeout(runtimeViewportTimerRef.current);
+      runtimeViewportTimerRef.current = null;
     }
-    setAutoViewportState((current) => current?.key === authoredViewportKey ? current : null);
+    adaptiveViewportRef.current = null;
+    requestViewportRef.current = null;
+    setRuntimeViewportState((current) => current?.key === authoredViewportKey ? current : null);
     return () => {
-      if (autoViewportTimerRef.current !== null) {
-        clearTimeout(autoViewportTimerRef.current);
-        autoViewportTimerRef.current = null;
+      if (runtimeViewportTimerRef.current !== null) {
+        clearTimeout(runtimeViewportTimerRef.current);
+        runtimeViewportTimerRef.current = null;
       }
     };
   }, [authoredViewportKey]);
-  const handleChartViewportChange = useCallback((next: { start: Date; end: Date } | null) => {
-    if (autoViewportTimerRef.current !== null) {
-      clearTimeout(autoViewportTimerRef.current);
-      autoViewportTimerRef.current = null;
+  const handleChartViewportChange = useCallback((
+    next: { start: Date; end: Date } | null,
+    interaction: "pan" | "reset" | "sync" | "zoom",
+  ) => {
+    if (interaction === "sync") return;
+    if (runtimeViewportTimerRef.current !== null) {
+      clearTimeout(runtimeViewportTimerRef.current);
+      runtimeViewportTimerRef.current = null;
     }
-    if (spec.viewport.resolution !== "auto" || !next) {
-      setAutoViewportState(null);
+    if (!next) {
+      adaptiveViewportRef.current = null;
+      requestViewportRef.current = null;
+      setRuntimeViewportState(null);
       return;
     }
     const start = next.start.getTime();
     const end = next.end.getTime();
     if (!Number.isFinite(start) || !Number.isFinite(end) || start > end) return;
-    autoViewportTimerRef.current = globalThis.setTimeout(() => {
-      autoViewportTimerRef.current = null;
-      setAutoViewportState((current) => (
-        current?.key === authoredViewportKey
-          && current.viewport.start.getTime() === start
-          && current.viewport.end.getTime() === end
-          ? current
-          : {
-              key: authoredViewportKey,
-              viewport: { start: new Date(start), end: new Date(end) },
-            }
-      ));
+    const viewport = { start: new Date(start), end: new Date(end) };
+    requestViewportRef.current = viewport;
+    if (interaction === "zoom" && spec.viewport.resolution === "auto") {
+      adaptiveViewportRef.current = viewport;
+    }
+    runtimeViewportTimerRef.current = globalThis.setTimeout(() => {
+      runtimeViewportTimerRef.current = null;
+      const requestViewport = requestViewportRef.current;
+      if (!requestViewport) return;
+      const adaptiveViewport = spec.viewport.resolution === "auto"
+        ? adaptiveViewportRef.current
+        : null;
+      setRuntimeViewportState({
+        key: authoredViewportKey,
+        adaptiveViewport,
+        requestViewport,
+      });
     }, AUTO_VIEWPORT_DEBOUNCE_MS);
   }, [authoredViewportKey, spec.viewport.resolution]);
 
@@ -564,8 +595,10 @@ export function ChartComposerSurface({
         <CompositeChart
           series={plottedSeries}
           legendSeries={resolution.legendSeries}
+          timelineSeries={resolution.timelineSeries}
           panels={spec.panels}
           viewport={viewport}
+          viewportResetKey={authoredViewportKey}
           width={Math.max(1, width)}
           height={Math.max(4, height - 1)}
           focused={focused}

package/src/plugins/builtin/chart-composer/presets.ts

@@ -30,7 +30,7 @@ import {
 } from "../../../utils/exchanges";
 import { MAX_CHART_COMPOSER_SERIES } from "./chart-spec";
 
-export const CHART_FIELD_IDS = {
+const CHART_FIELD_IDS = {
   price: "market.ohlcv",
   close: "market.close",
   volume: "market.volume",
@@ -45,8 +45,6 @@ export const CHART_FIELD_IDS = {
   evEbitda: "valuation.evEbitda",
 } as const;
 
-export type ChartComposerPreset = "G" | "GP" | "GIP" | "CMP" | "GF" | "GE";
-
 export type ParsedSeriesExpression =
   | { kind: "security"; symbol: string; exchange?: string; fieldId: string; label?: string }
   | { kind: "economic"; provider: "fred"; seriesId: string; label?: string };
@@ -647,22 +645,6 @@ export function buildValuationChartPreset(
   )));
 }
 
-export function buildPresetChartSpec(
-  preset: ChartComposerPreset,
-  symbols: readonly string[],
-  expression = "",
-): ChartSpec {
-  const primary = symbols[0] ?? "";
-  switch (preset) {
-    case "G": return buildCustomChartPreset(expression, primary || null);
-    case "GP": return buildPriceChartPreset(primary);
-    case "GIP": return buildIntradayPriceChartPreset(primary);
-    case "CMP": return buildComparisonChartPreset(symbols);
-    case "GF": return buildFundamentalChartPreset(symbols);
-    case "GE": return buildValuationChartPreset(symbols);
-  }
-}
-
 const STUDY_DEFAULTS = {
   volume: { kind: "volume", panelId: "volume", parameters: {} },
   sma20: { kind: "sma", panelId: "main", parameters: { period: 20 } },

package/src/plugins/builtin/chart-composer/settings.ts

@@ -129,7 +129,7 @@ function reconcileBasePanels(
   ));
 }
 
-export function replaceChartSeriesFromExpression(
+function replaceChartSeriesFromExpression(
   spec: ChartSpec,
   expression: string,
 ): ChartSpec {

package/src/plugins/builtin/chat/content/composer-runtime.ts

@@ -364,7 +364,7 @@ export function useChatComposerRuntime({
   const inputPlaceholder = editingMessage
     ? t("Edit message...")
     : replyTo
-      ? tf("Reply to @{username}...", { username: replyTo.user.username })
+      ? tf("Reply to @{username}...", { username: replyTo.user.username ?? "unknown" })
       : t("Type a message...");
 
   return {

package/src/plugins/builtin/chat/content/shortcuts.ts

@@ -88,7 +88,6 @@ export function useChatContentShortcuts({
       || event.meta
       || event.super
       || event.alt
-      || event.option
     ) {
       return;
     }

package/src/plugins/builtin/chat/controller/fetch.ts

@@ -23,13 +23,18 @@ export async function fetchLatestChannelMessages(
   const hasIncrementalCursor = !!channel.lastCursor;
   const hadMessages = channel.messages.length > 0;
   const countIncrementalUnread = hadMessages && hasIncrementalCursor && !legacyTimestampCursor;
+  // The first fetch of a session drops the cursor so anything missed while the
+  // socket was connected comes back. Merging is keyed by message id, so
+  // re-reading known messages changes nothing and counts no unread.
+  const backfillGaps = !channel.backfilled;
 
   try {
     const messages = await apiClient.getMessages(channelId, {
       limit: MESSAGE_PAGE_SIZE,
-      after: channel.lastCursor ?? undefined,
+      after: backfillGaps ? undefined : channel.lastCursor ?? undefined,
     });
-    if (!hasIncrementalCursor && messages.length < MESSAGE_PAGE_SIZE) {
+    channel.backfilled = true;
+    if ((!hasIncrementalCursor || backfillGaps) && messages.length < MESSAGE_PAGE_SIZE) {
       channel.reachedOldestMessage = true;
     }
     if (messages.length > 0) {
@@ -51,6 +56,7 @@ export async function fetchLatestChannelMessages(
     return;
   } catch {
     const messages = await apiClient.getMessages(channelId, { limit: MESSAGE_PAGE_SIZE });
+    channel.backfilled = true;
     if (messages.length < MESSAGE_PAGE_SIZE) {
       channel.reachedOldestMessage = true;
     }

package/src/plugins/builtin/chat/controller/persistence.ts

@@ -21,6 +21,7 @@ export interface ChatSessionUser {
   id: string;
   username: string;
   emailVerified: boolean;
+  plan?: "free" | "pro";
 }
 
 export function readChatSessionState(
@@ -40,6 +41,7 @@ export function normalizeSessionUser(user: PersistedAuthUser | null | undefined)
       id: user.id,
       username: user.username ?? user.name ?? "account",
       emailVerified: user.emailVerified === true,
+      plan: user.plan,
     }
     : null;
 }

package/src/plugins/builtin/chat/controller/session.test.ts

@@ -0,0 +1,25 @@
+import { describe, expect, test } from "bun:test";
+import { normalizeSessionUser } from "./persistence";
+import { sessionUserFromApiSession } from "./session";
+
+describe("chat session market entitlement", () => {
+  test("preserves plan through cached and refreshed desktop session mappings", () => {
+    expect(
+      normalizeSessionUser({
+        id: "user-1",
+        emailVerified: true,
+        username: "vince",
+        plan: "pro",
+      }),
+    ).toMatchObject({ id: "user-1", plan: "pro" });
+
+    expect(
+      sessionUserFromApiSession({
+        id: "user-1",
+        emailVerified: true,
+        username: "vince",
+        plan: "free",
+      }),
+    ).toMatchObject({ id: "user-1", plan: "free" });
+  });
+});

package/src/plugins/builtin/chat/controller/session.ts

@@ -8,6 +8,7 @@ export type ChatApiSession = {
   username?: string | null;
   name?: string | null;
   emailVerified?: boolean | null;
+  plan?: "free" | "pro";
 };
 
 export function getSessionIdentity(user: ChatSessionUser | null): string {
@@ -19,6 +20,7 @@ export function sessionUserFromApiSession(session: ChatApiSession): ChatSessionU
     id: session.id,
     username: session.username ?? session.name ?? "account",
     emailVerified: !!session.emailVerified,
+    plan: session.plan,
   };
 }
 

package/src/plugins/builtin/chat/controller/state.ts

@@ -73,6 +73,12 @@ export interface ChannelRuntimeState {
   refreshMessagesPromise: Promise<void> | null;
   loadOlderMessagesPromise: Promise<void> | null;
   reachedOldestMessage: boolean;
+  /**
+   * False until this session has fetched a full latest page. The incremental
+   * cursor only ever asks for newer messages, so a message missed live can
+   * never be requested again; one uncursored fetch per session repairs it.
+   */
+  backfilled: boolean;
   messages: ChatMessage[];
   pendingMessages: ChatMessage[];
   draft: string;
@@ -105,6 +111,7 @@ export function createEmptyChannelState(): ChannelRuntimeState {
     refreshMessagesPromise: null,
     loadOlderMessagesPromise: null,
     reachedOldestMessage: false,
+    backfilled: false,
     messages: [],
     pendingMessages: [],
     draft: "",

package/src/plugins/builtin/chat/controller.test.ts

@@ -501,19 +501,76 @@ describe("ChatController", () => {
     const calls: Array<{ channelId: string; opts?: { after?: string; before?: string; limit?: number } }> = [];
     apiClient.getMessages = async (channelId, opts) => {
       calls.push({ channelId, opts });
-      return opts?.after === "m1" ? [next] : [];
+      if (!opts?.after) return [initial, next];
+      return opts.after === "m1" ? [next] : [];
     };
 
     await controller.refreshMessages();
 
-    expect(calls).toEqual([{
-      channelId: "everyone",
-      opts: { limit: 50, after: "m1" },
-    }]);
+    expect(calls[0]?.opts?.after).toBeUndefined();
     expect(controller.getSnapshot().messages.map((entry) => entry.id)).toEqual(["m1", "m2"]);
     expect(persistence.getState<{ lastCursor: string }>("channel:everyone", { schemaVersion: 1 })).toMatchObject({
       lastCursor: "m2",
     });
+
+    await controller.refreshMessages();
+
+    expect(calls[1]?.opts?.after).toBe("m2");
+  });
+
+  test("recovers a message the cursor already moved past", async () => {
+    const persistence = new MemoryPersistence();
+    const controller = new ChatController();
+    const asked: ChatMessage = {
+      id: "m1",
+      channelId: "everyone",
+      content: "why is the chart glitching",
+      replyToId: null,
+      createdAt: "2026-03-28T00:00:00.000Z",
+      user: { id: "u1", username: "vince", displayName: "Vince" },
+    };
+    const missed: ChatMessage = {
+      id: "m2",
+      channelId: "everyone",
+      content: "charts open with GP",
+      replyToId: "m1",
+      createdAt: "2026-03-28T00:01:00.000Z",
+      user: { id: "u2", username: "gloombot", displayName: "Gloombot" },
+    };
+    const acknowledged: ChatMessage = {
+      id: "m3",
+      channelId: "everyone",
+      content: "got it",
+      replyToId: null,
+      createdAt: "2026-03-28T00:02:00.000Z",
+      user: { id: "u1", username: "vince", displayName: "Vince" },
+    };
+
+    // The cursor already sits on m3, so an incremental fetch can never ask for
+    // m2 again even though the server still has it.
+    persistence.setState("channel:everyone", {
+      draft: "",
+      replyToId: null,
+      lastCursor: "m3",
+      lastViewedMessageId: "m3",
+    }, { schemaVersion: 1 });
+    persistence.setResource(TRANSCRIPT_KIND, TRANSCRIPT_KEY, {
+      messages: [asked, acknowledged],
+    }, {
+      sourceKey: TRANSCRIPT_SOURCE,
+      schemaVersion: TRANSCRIPT_SCHEMA_VERSION,
+      cachePolicy: { staleMs: 1_000, expireMs: 2_000 },
+    });
+
+    controller.attachPersistence(persistence);
+
+    apiClient.getMessages = async (_channelId, opts) => (
+      opts?.after ? [] : [asked, missed, acknowledged]
+    );
+
+    await controller.refreshMessages();
+
+    expect(controller.getSnapshot().messages.map((entry) => entry.id)).toEqual(["m1", "m2", "m3"]);
   });
 
   test("hydrates missing transcript cache without marking history unread", async () => {
@@ -603,19 +660,21 @@ describe("ChatController", () => {
     const calls: Array<{ channelId: string; opts?: { after?: string; before?: string; limit?: number } }> = [];
     apiClient.getMessages = async (channelId, opts) => {
       calls.push({ channelId, opts });
-      return opts?.after === "m1" ? [fresh] : [];
+      return opts?.after ? [] : [cached, fresh];
     };
 
     await controller.refreshMessages();
 
-    expect(calls).toEqual([{
-      channelId: "everyone",
-      opts: { limit: 50, after: "m1" },
-    }]);
+    expect(calls[0]?.opts?.after).toBeUndefined();
     expect(controller.getSnapshot().messages.map((entry) => entry.id)).toEqual(["m1", "m2"]);
     expect(persistence.getState<{ lastCursor: string }>("channel:everyone", { schemaVersion: 1 })).toMatchObject({
       lastCursor: "m2",
     });
+
+    await controller.refreshMessages();
+
+    // The stale m99 cursor never reaches the server.
+    expect(calls[1]?.opts?.after).toBe("m2");
   });
 
   test("shows a pending message immediately and replaces it when the send succeeds", async () => {
@@ -1398,16 +1457,10 @@ describe("ChatController", () => {
 
     await controller.refreshMessages();
 
-    expect(calls).toEqual([
-      {
-        channelId: "everyone",
-        opts: { limit: 50, after: "2026-03-28T00:00:00.000Z" },
-      },
-      {
-        channelId: "everyone",
-        opts: { limit: 50 },
-      },
-    ]);
+    // The session backfill already ignores the cursor, so the legacy timestamp
+    // is never sent and the old wasted round trip is gone.
+    expect(calls).toHaveLength(1);
+    expect(calls[0]?.opts?.after).toBeUndefined();
     expect(controller.getSnapshot().messages.map((entry) => entry.id)).toEqual(["m1", "m2"]);
     expect(persistence.getState<{ lastCursor: string }>("channel:everyone", { schemaVersion: 1 })).toMatchObject({
       lastCursor: "m2",

package/src/plugins/builtin/chat/message/desktop.tsx

@@ -2,6 +2,7 @@ import { memo } from "react";
 import { Box, Span, Text } from "../../../../ui";
 import { hoverBg } from "../../../../theme/colors";
 import { t } from "../../../../i18n";
+import { useAppLanguage } from "../../../../i18n/react";
 import { MESSAGE_ACTION_WIDTH, normalizeInlinePreview } from "../layout";
 import { ChatActionChip } from "./action-chip";
 import { ResponsiveTickerBadgeText } from "./inline-tokens";
@@ -30,6 +31,7 @@ export const DesktopChatMessage = memo(function DesktopChatMessage({
 }: ChatMessageBaseProps & {
   registerMessageElement: (messageId: string, node: unknown | null) => void;
 }) {
+  useAppLanguage();
   const state = getChatMessageRenderState({ msg, index, messages, selectedIdx, hoveredIdx, canSend });
   const canEditMessage = msg.id === latestEditableMessageId;
   const showInlineReplyAction = !state.grouped && canSend;

package/src/plugins/builtin/cloud-tweets/footer.ts

@@ -1,40 +1,21 @@
-import { usePaneFooter } from "../../../components";
+import { useMemo } from "react";
+import type { PaneFooterSegment } from "../../../components";
 import { formatTimeAgo } from "../../../utils/format";
 import {
   TWITTER_FEED_PANE_ID,
   type TwitterFeed,
 } from "./model";
+import { usePaneStatusFooter } from "../shared/pane-footer";
 
 export function useTwitterFeedFooter({
   activeFeed,
-  addFeed,
-  blurSearch,
-  focusSearch,
-  removeFeed,
-  searchFocused,
 }: {
   activeFeed: TwitterFeed | null;
-  addFeed: () => void;
-  blurSearch: () => void;
-  focusSearch: () => void;
-  removeFeed: (feedId: string) => void;
-  searchFocused: boolean;
 }) {
-  usePaneFooter(TWITTER_FEED_PANE_ID, () => ({
-    info: activeFeed
-      ? [
-        { id: "mode", parts: [{ text: activeFeed.queryType, tone: "value" }] },
-        ...(activeFeed.lastSuccessAt ? [{ id: "last", parts: [{ text: `ran ${formatTimeAgo(new Date(activeFeed.lastSuccessAt))}`, tone: "muted" as const }] }] : []),
-      ]
-      : [],
-    hints: searchFocused
-      ? [
-        { id: "done", key: "Esc", label: "done", onPress: blurSearch },
-      ]
-      : [
-        { id: "new", key: "n", label: "ew", onPress: () => addFeed() },
-        { id: "search", key: "/", label: "search", onPress: focusSearch, disabled: !activeFeed },
-        { id: "delete", key: "d", label: "elete", onPress: activeFeed ? () => removeFeed(activeFeed.id) : undefined, disabled: !activeFeed },
-      ],
-  }), [activeFeed, addFeed, blurSearch, focusSearch, removeFeed, searchFocused]);
+  const info = useMemo<PaneFooterSegment[]>(() => (
+    activeFeed?.lastSuccessAt
+      ? [{ id: "last", parts: [{ text: `ran ${formatTimeAgo(new Date(activeFeed.lastSuccessAt))}`, tone: "muted" }] }]
+      : []
+  ), [activeFeed?.lastSuccessAt]);
+  usePaneStatusFooter({ registrationId: TWITTER_FEED_PANE_ID, info });
 }

package/src/plugins/builtin/cloud-tweets/pane.tsx

@@ -249,11 +249,6 @@ export function TwitterFeedPane({ focused, width, height }: PaneProps) {
 
   useTwitterFeedFooter({
     activeFeed,
-    addFeed,
-    blurSearch,
-    focusSearch,
-    removeFeed,
-    searchFocused,
   });
 
   const searchBar = activeFeed ? (

package/src/plugins/builtin/cloud-tweets/table.tsx

@@ -1,9 +1,8 @@
 import { useCallback, useEffect, useMemo, useRef, useState, type ReactNode } from "react";
-import { Box, ScrollBox, Text, TextAttributes, useRendererHost } from "../../../ui";
+import { Box, ScrollBox, Text, TextAttributes } from "../../../ui";
 import {
   DataTableStackView,
   TickerBadgeList,
-  usePaneFooter,
   type DataTableCell,
   type DataTableKeyEvent,
   type DataTableRootKeyContext,
@@ -34,6 +33,7 @@ import {
   type TweetSortColumnId,
   type TweetSortDirection,
 } from "./model";
+import { usePaneStatusLinkFooter } from "../shared/pane-footer";
 
 function isAuthError(error: string | null): boolean {
   return !!error && /unauthorized|verification/i.test(error);
@@ -172,7 +172,6 @@ export function TweetSearchTable({
   emptyStateTitle?: string;
   emptyStateHint?: string;
 }) {
-  const rendererHost = useRendererHost();
   const { createPaneFromTemplate } = usePluginAppActions();
   const { data, loading, error, reload } = useTweetSearchData(requestKey, load, onResult, onError, enabled);
   const [selectedTweetId, setSelectedTweetId] = useState<string | null>(null);
@@ -186,6 +185,16 @@ export function TweetSearchTable({
   const selectedIndex = rows.findIndex((tweet) => tweet.id === selectedTweetId);
   const activeIndex = selectedIndex >= 0 ? selectedIndex : rows.length > 0 ? 0 : -1;
   const selectedTweet = rows[activeIndex] ?? null;
+  const openSelectedTweet = usePaneStatusLinkFooter({
+    registrationId: footerId,
+    focused,
+    url: detailOpen ? selectedTweet?.url : null,
+    source: detailOpen && selectedTweet
+      ? `@${selectedTweet.author.userName || selectedTweet.author.name}`
+      : null,
+    loading,
+    error,
+  });
 
   useEffect(() => {
     if (rows.length === 0) {
@@ -198,9 +207,6 @@ export function TweetSearchTable({
     }
   }, [rows, selectedIndex, selectedTweetId]);
 
-  const openSelectedTweet = useCallback(() => {
-    if (selectedTweet?.url) void rendererHost.openExternal(selectedTweet.url);
-  }, [rendererHost, selectedTweet]);
   const openUsernameFeed = useCallback((username: string) => {
     const normalizedUsername = normalizeTwitterUsername(username);
     if (!normalizedUsername) return;
@@ -247,17 +253,6 @@ export function TweetSearchTable({
     return true;
   }, [openSelectedTweet]);
 
-  usePaneFooter(footerId, () => ({
-    info: [
-      ...(loading ? [{ id: "loading", parts: [{ text: "loading", tone: "muted" as const }] }] : []),
-      ...(error ? [{ id: "error", parts: [{ text: error, tone: "warning" as const }] }] : []),
-    ],
-    hints: [
-      { id: "refresh", key: "r", label: "efresh", onPress: reload },
-      ...(detailOpen ? [{ id: "open", key: "o", label: "pen", onPress: openSelectedTweet, disabled: !selectedTweet?.url }] : []),
-    ],
-  }), [detailOpen, error, footerId, loading, openSelectedTweet, reload, selectedTweet?.url]);
-
   const renderCell = useCallback((
     tweet: CloudTweetPayload,
     column: TweetColumn,