gloomberb 0.13.2 → 0.14.0

package/src/components/data-table/view.test.tsx

@@ -1,6 +1,7 @@
 import { afterEach, describe, expect, test } from "bun:test";
 import { act, useState } from "react";
-import { testRender } from "../../renderers/opentui/test-utils";
+import type { ScrollBoxRenderable } from "@opentui/core";
+import { emitKeypress as emitTuiKeypress, testRender, type TestKeyEvent } from "../../renderers/opentui/test-utils";
 import {
   AppContext,
   PaneInstanceProvider,
@@ -8,8 +9,8 @@ import {
 } from "../../state/app/context";
 import { createDefaultConfig } from "../../types/config";
 import { Box, Text } from "../../ui";
-import { DataTableView } from "./view";
 import type { DataTableCell, DataTableColumn } from "../ui";
+import { DataTableView } from "./view";
 
 type Row =
   | { type: "section"; id: string; title: string }
@@ -132,69 +133,62 @@ function LargeSelectionHarness({
   );
 }
 
-async function renderSettled() {
-  await act(async () => {
-    await testSetup!.renderOnce();
-    await testSetup!.renderOnce();
-  });
-}
+let setDeferredRows: ((rows: Row[]) => void) | undefined;
+let setRequestedIndex: ((index: number) => void) | undefined;
 
-async function emitKeypress(event: {
-  name?: string;
-  sequence?: string;
-  ctrl?: boolean;
-  meta?: boolean;
-  shift?: boolean;
-  option?: boolean;
-  defaultPrevented?: boolean;
-  propagationStopped?: boolean;
+function DeferredScrollHarness({ onScroll, initialRows = [], initialIndex = 500, controlSelection = false }: {
+  onScroll?: (source?: "programmatic" | "user") => void;
+  initialRows?: Row[];
+  initialIndex?: number;
+  controlSelection?: boolean;
 }) {
-  await act(async () => {
-    testSetup!.renderer.keyInput.emit("keypress", {
-      ctrl: false,
-      meta: false,
-      option: false,
-      shift: false,
-      eventType: "press",
-      repeated: false,
-      defaultPrevented: false,
-      propagationStopped: false,
-      preventDefault: () => {},
-      stopPropagation: () => {},
-      ...event,
-    } as any);
-    await testSetup!.renderOnce();
-  });
+  const [items, setItems] = useState<Row[]>(initialRows);
+  const [requestedIndex, requestIndex] = useState(initialIndex);
+  setDeferredRows = setItems;
+  setRequestedIndex = requestIndex;
+  const state = createInitialState(createDefaultConfig("/tmp/gloomberb-table-deferred-scroll"));
+  return (
+    <AppContext value={{ state, dispatch: () => {} }}>
+      <PaneInstanceProvider paneId="deferred-scroll-test">
+        <DataTableView<Row, Column>
+          focused
+          selection={controlSelection
+            ? { kind: "index", selectedIndex: requestedIndex, onChange: requestIndex }
+            : { kind: "none" }}
+          columns={columns}
+          items={items}
+          sortColumnId={null}
+          sortDirection="asc"
+          onHeaderClick={() => {}}
+          getItemKey={(row) => row.id}
+          renderCell={(row) => ({ text: row.title })}
+          emptyStateTitle="Loading rows"
+          bodyScrollId="deferred-scroll-body"
+          scrollToIndex={requestedIndex}
+          scrollToIndexAlign="center"
+          resetScrollKey="contract-chain"
+          onBodyScrollActivity={onScroll}
+        />
+      </PaneInstanceProvider>
+    </AppContext>
+  );
 }
 
-async function emitKeypressBatch(events: Array<{
-  name?: string;
-  sequence?: string;
-  ctrl?: boolean;
-  meta?: boolean;
-  shift?: boolean;
-  option?: boolean;
-}>) {
-  await act(async () => {
-    for (const event of events) {
-      testSetup!.renderer.keyInput.emit("keypress", {
-        ctrl: false,
-        meta: false,
-        option: false,
-        shift: false,
-        eventType: "press",
-        repeated: false,
-        defaultPrevented: false,
-        propagationStopped: false,
-        preventDefault: () => {},
-        stopPropagation: () => {},
-        ...event,
-      } as any);
-    }
-    await testSetup!.renderOnce();
-  });
+async function renderSettled() {
+  // Commit React's measurement/scroll effects between native frames, then
+  // paint the resulting viewport. One act around every frame can leave the
+  // numeric scroll offset updated while the captured frame is still old.
+  for (let phase = 0; phase < 3; phase += 1) {
+    await act(async () => {
+      await testSetup!.renderOnce();
+    });
+  }
 }
 
+const emitKeypress = (event: TestKeyEvent) => emitTuiKeypress(testSetup!, event);
+
+const emitKeypressBatch = (events: TestKeyEvent[]) => emitTuiKeypress(testSetup!, events);
+
 describe("DataTableView", () => {
   test("owns row keyboard navigation and skips section headers", async () => {
     testSetup = await testRender(<Harness />, { width: 60, height: 12 });
@@ -202,22 +196,24 @@ describe("DataTableView", () => {
     await renderSettled();
     expect(testSetup.captureCharFrame()).toContain("cursor=First row selected=First row");
 
+    // The first step after a pause commits at once; the steps that follow
+    // inside the commit window only move the cursor.
     await emitKeypress({ name: "down", sequence: "\u001B[B" });
     await renderSettled();
-    expect(testSetup.captureCharFrame()).toContain("cursor=Second row selected=First row");
+    expect(testSetup.captureCharFrame()).toContain("cursor=Second row selected=Second row");
 
     await emitKeypress({ name: "up", sequence: "\u001B[A", meta: true });
     await renderSettled();
-    expect(testSetup.captureCharFrame()).toContain("cursor=Second row selected=First row");
+    expect(testSetup.captureCharFrame()).toContain("cursor=Second row selected=Second row");
 
     await emitKeypress({ name: "up", sequence: "\u001B[A" });
     await renderSettled();
-    expect(testSetup.captureCharFrame()).toContain("cursor=First row selected=First row");
+    expect(testSetup.captureCharFrame()).toContain("cursor=First row selected=Second row");
 
     await emitKeypress({ name: "j", sequence: "j" });
     await emitKeypress({ name: "k", sequence: "k" });
     await renderSettled();
-    expect(testSetup.captureCharFrame()).toContain("cursor=First row selected=First row");
+    expect(testSetup.captureCharFrame()).toContain("cursor=First row selected=Second row");
 
     await emitKeypress({ name: "enter", sequence: "\r" });
     await renderSettled();
@@ -297,3 +293,51 @@ describe("DataTableView", () => {
     expect(renderedCells - beforeNavigation).toBeLessThanOrEqual(4);
   });
 });
+
+test("fulfills a center request after rows are laid out and then leaves manual scrolling alone", async () => {
+  const scrollSources: Array<"programmatic" | "user" | undefined> = [];
+  testSetup = await testRender(
+    <DeferredScrollHarness onScroll={(source) => scrollSources.push(source)} />,
+    { width: 60, height: 12 },
+  );
+  await renderSettled();
+  await act(async () => { setDeferredRows!(largeRows); });
+  await renderSettled();
+  const body = testSetup.renderer.root.findDescendantById("deferred-scroll-body") as ScrollBoxRenderable;
+  expect(body.scrollTop).toBe(500 - Math.floor(body.viewport.height / 2));
+  expect(testSetup.captureCharFrame()).toContain("Row 500");
+  expect(scrollSources.at(-1)).toBe("programmatic");
+
+  await act(async () => { body.scrollTo(50); });
+  await renderSettled();
+  await act(async () => { setDeferredRows!([...largeRows, { type: "row", id: "new", title: "New row" }]); });
+  await renderSettled();
+  expect(body.scrollTop).toBe(50);
+  expect(scrollSources.at(-1)).toBe("user");
+
+  await act(async () => { setDeferredRows!([]); });
+  await renderSettled();
+  expect(body.scrollTop).toBe(0);
+  expect(scrollSources.at(-1)).toBe("programmatic");
+  expect(testSetup.captureCharFrame()).toContain("Loading rows");
+  await act(async () => { setDeferredRows!(largeRows); });
+  await renderSettled();
+  expect(body.scrollTop).toBe(500 - Math.floor(body.viewport.height / 2));
+  await act(async () => { body.scrollTo(50); });
+  await renderSettled();
+  expect(scrollSources.at(-1)).toBe("user");
+});
+
+
+test("an external selection and scroll request cannot be reversed by the previous cursor", async () => {
+  testSetup = await testRender(
+    <DeferredScrollHarness initialRows={largeRows} initialIndex={0} controlSelection />,
+    { width: 60, height: 12 },
+  );
+  await renderSettled();
+  await act(async () => { setRequestedIndex!(500); });
+  await renderSettled();
+  const body = testSetup.renderer.root.findDescendantById("deferred-scroll-body") as ScrollBoxRenderable;
+  expect(body.scrollTop).toBe(500 - Math.floor(body.viewport.height / 2));
+  expect(testSetup.captureCharFrame()).toContain("Row 500");
+});

package/src/components/data-table/view.tsx

@@ -9,6 +9,7 @@ import {
 } from "react";
 import type { ScrollBoxRenderable } from "../../ui";
 import { useShortcut } from "../../react/input";
+import { isPlainKeyboardEvent } from "../../utils/keyboard";
 import { DataTable, type DataTableColumn, type DataTableProps } from "../ui";
 import {
   isNextTableRowKey,
@@ -99,7 +100,7 @@ export interface DataTableViewProps<
   headerScrollRef?: RefObject<ScrollBoxRenderable | null>;
   scrollRef?: RefObject<ScrollBoxRenderable | null>;
   syncHeaderScroll?: () => void;
-  onBodyScrollActivity?: () => void;
+  onBodyScrollActivity?: DataTableProps<T, C>["onBodyScrollActivity"];
   keyboardNavigation?: boolean;
   onRootKeyDown?: (
     event: DataTableKeyEvent,
@@ -148,6 +149,7 @@ export function DataTableView<
   const pendingCommitTimerRef = useRef<ReturnType<typeof setTimeout> | null>(
     null,
   );
+  const lastKeyboardCommitAtRef = useRef(Number.NEGATIVE_INFINITY);
   const selectionKey = selection.kind === "id"
     ? selection.selectedId
     : selection.kind === "index"
@@ -318,10 +320,14 @@ export function DataTableView<
       || previous.key !== current.key;
     const selectedRowAppeared = !previous?.resolved && current.resolved;
     if (selectionChanged || selectedRowAppeared) {
-      requestSelectionScroll(effectiveSelectedIndex);
+      // An external selection renders before the optimistic cursor's syncing
+      // effect commits. Scroll to the new selection, retaining an immediate
+      // cursor only while a keyboard navigation commit is still pending.
+      requestSelectionScroll(pendingCommitRef.current ? effectiveSelectedIndex : defaultCursorIndex);
     }
   }, [
     clearSelectionScrollTarget,
+    defaultCursorIndex,
     effectiveSelectedIndex,
     requestSelectionScroll,
     scrollToIndex,
@@ -384,6 +390,7 @@ export function DataTableView<
   ) => {
     const target = getCommitTarget(index);
     clearPendingCommit();
+    lastKeyboardCommitAtRef.current = performance.now();
     commitTarget(target, reason);
   }, [clearPendingCommit, commitTarget, getCommitTarget]);
 
@@ -391,6 +398,14 @@ export function DataTableView<
     if (selection.kind === "none") return;
     const target = getCommitTarget(index);
     if (!target) return;
+    // The first step after a pause commits at once, so a follower pane moves
+    // with the cursor; steps that follow within the delay collapse into one
+    // trailing commit, which is what keeps a held key from firing a load per
+    // row.
+    if (!pendingCommitRef.current && performance.now() - lastKeyboardCommitAtRef.current >= DATA_TABLE_SELECTION_COMMIT_DELAY_MS) {
+      commitIndexImmediately(index, "keyboard");
+      return;
+    }
     if (pendingCommitTimerRef.current) {
       clearTimeout(pendingCommitTimerRef.current);
     }
@@ -402,9 +417,10 @@ export function DataTableView<
       const pendingTarget = pendingCommitTargetRef.current;
       pendingCommitTargetRef.current = null;
       clearSelectionScrollTarget();
+      lastKeyboardCommitAtRef.current = performance.now();
       commitTarget(pendingTarget, "keyboard");
     }, DATA_TABLE_SELECTION_COMMIT_DELAY_MS);
-  }, [clearSelectionScrollTarget, commitTarget, getCommitTarget, selection.kind]);
+  }, [clearSelectionScrollTarget, commitIndexImmediately, commitTarget, getCommitTarget, selection.kind]);
 
   const updateCursorIndex = useCallback((
     index: number,
@@ -536,6 +552,27 @@ export function DataTableView<
     })) return;
     if (tableProps.items.length === 0) return;
 
+    // Leave plain arrows to tabs and modified text-selection keys to editors.
+    if (event.ctrl && isPlainKeyboardEvent({ ...event, ctrl: false })
+      && !event.targetEditable && tableProps.showHorizontalScrollbar !== false
+      && (event.name === "left" || event.name === "right")) {
+      const body = effectiveScrollRef.current;
+      const viewportWidth = body?.viewport?.width ?? 0;
+      const currentLeft = body?.scrollLeft ?? 0;
+      const maxLeft = Math.max(0, (body?.scrollWidth ?? 0) - viewportWidth);
+      if (body && viewportWidth > 0 && maxLeft > 0) {
+        const direction = event.name === "left" ? -1 : 1;
+        const nextLeft = Math.max(0, Math.min(maxLeft,
+          currentLeft + direction * Math.max(1, Math.floor(viewportWidth / 2))));
+        if (nextLeft !== currentLeft) {
+          body.scrollLeft = nextLeft;
+          effectiveSyncHeaderScroll();
+          stopTableKey(event);
+        }
+      }
+      return;
+    }
+
     if (isNextTableRowKey(event)) {
       stopTableKey(event);
       selectByOffset(1);

package/src/components/feed-data-table/stack-view.tsx

@@ -63,9 +63,13 @@ interface FeedDataTableStackViewProps {
   emptyStateHint?: string;
   isItemRead?: (item: FeedDataTableItem) => boolean;
   onOpenItem?: (item: FeedDataTableItem, index: number) => void;
+  /** Controlled open item, for panes that keep it in pane state so it restores and travels with a share. */
+  openItemId?: string | null;
   onOpenItemIdChange?: (itemId: string | null) => void;
   scrollRef?: RefObject<ScrollBoxRenderable | null>;
   onBodyScrollActivity?: () => void;
+  /** Warms the detail of an item once the cursor rests on its row; see DataTableStackView. */
+  prefetchDetail?: (item: FeedDataTableItem, index: number) => void;
 }
 
 function timestampValue(item: FeedDataTableItem): number {
@@ -149,16 +153,24 @@ export function FeedDataTableStackView({
   emptyStateHint,
   isItemRead,
   onOpenItem,
+  openItemId: controlledOpenItemId,
   onOpenItemIdChange,
   scrollRef,
   onBodyScrollActivity,
+  prefetchDetail,
 }: FeedDataTableStackViewProps) {
   const language = useAppLanguage();
   const [sortPreference, setSortPreference] = useState<SortPreference>({
     columnId: "time",
     direction: "desc",
   });
-  const [openItemId, setOpenItemId] = useState<string | null>(null);
+  const [localOpenItemId, setLocalOpenItemId] = useState<string | null>(null);
+  const controlled = controlledOpenItemId !== undefined;
+  const openItemId = controlled ? controlledOpenItemId : localOpenItemId;
+  const setOpenItemId = useCallback((itemId: string | null) => {
+    if (controlled) onOpenItemIdChange?.(itemId);
+    else setLocalOpenItemId(itemId);
+  }, [controlled, onOpenItemIdChange]);
   const detailScrollRef = useRef<ScrollBoxRenderable>(null);
   const detailTextWidth = Math.max(width - 2, 12);
   const columns = useMemo(
@@ -201,14 +213,16 @@ export function FeedDataTableStackView({
   }, [onOpenItem]);
 
   useEffect(() => {
-    if (openItemId && !openItem) {
+    // A controlled id may name an item that is still loading; the owner
+    // decides when to give it up.
+    if (openItemId && !openItem && !controlled) {
       setOpenItemId(null);
     }
-  }, [openItem, openItemId]);
+  }, [controlled, openItem, openItemId, setOpenItemId]);
 
   useEffect(() => {
-    onOpenItemIdChange?.(activeOpenItemId);
-  }, [activeOpenItemId, onOpenItemIdChange]);
+    if (!controlled) onOpenItemIdChange?.(activeOpenItemId);
+  }, [activeOpenItemId, controlled, onOpenItemIdChange]);
 
   useEffect(() => {
     if (!openItemId) return;
@@ -347,6 +361,7 @@ export function FeedDataTableStackView({
         onChange: (_index, row) => onSelect(row.itemIndex),
       }}
       onActivate={(row) => openRow(row)}
+      prefetchDetail={prefetchDetail ? (row) => prefetchDetail(row.item, row.itemIndex) : undefined}
       rootBefore={rootBefore}
       rootAfter={rootAfter}
       rootWidth={width}

package/src/components/index.ts

@@ -1,6 +1,27 @@
 
 export { PriceSelectorDialog } from "./price-selector-dialog";
 export { StaticChartSurface } from "./chart/static";
+export type { StaticChartOverlay } from "./chart/static/chart-surface";
+// The time-series chart: one or more panels of resolved series with axes,
+// a cursor, and range selection. Ticker overview, polls, econ statistics,
+// and prediction markets all draw with it.
+export { CompositeChart, pricePointsToResolvedSeries } from "./chart/composite";
+export type {
+  CompositeAxisDomain,
+  CompositeAxisSide,
+  CompositeChartColors,
+  CompositeChartProps,
+  CompositeChartScene,
+  CompositeCursorValue,
+  CompositePanelScene,
+  CompositeProjectedPoint,
+  CompositeProjectedSeries,
+  PricePointsToResolvedSeriesOptions,
+} from "./chart/composite";
+// A static chart's callers project their own points and pick a palette; these
+// are the same helpers the host's gauges and sparklines use to do that.
+export type { ProjectedChartPoint } from "./chart/core/data";
+export { resolveChartPalette } from "./chart/core/palette";
 export {
   buildMetricTreemapNavigationTiles,
   findMetricTreemapNeighbor,
@@ -12,6 +33,11 @@ export { SpeedometerGauge } from "./speedometer-gauge";
 export type { SpeedometerSegment } from "./speedometer-gauge";
 export { TickerListTableView } from "./ticker/list-table-view";
 export type { TickerListVisibleRange } from "./ticker/list-table-view";
+// What `TickerListTableView` puts in each configured column, and the value it
+// sorts on. A pane that shows the user's own column set has to read them the
+// same way or its rows disagree with the portfolio's.
+export { getColumnValue, getSortValue } from "../plugins/builtin/portfolio-list/column-values";
+export type { ColumnContext } from "../plugins/builtin/portfolio-list/column-values";
 export { TickerBadgeList } from "./ticker/badge/list";
 export { TickerBadgeText } from "./ticker/badge/text";
 export { InputSearchBar } from "./input-search-bar";
@@ -23,11 +49,21 @@ export type {
   DataTableSelectionChangeReason,
 } from "./data-table/view";
 export { DataTableStackView } from "./data-table/stack-view";
+// Row cells that cost real work to derive (formatting, unit resolution,
+// per-row lookups) recomputed only when that row's data version changes, so a
+// table re-render on selection or scroll does not redo all of it.
+export { createRowValueCache } from "./ui/row-value-cache";
+export type { RowValueCache } from "./ui/row-value-cache";
 export { FeedDataTableStackView } from "./feed-data-table/stack-view";
 export type { FeedDataTableItem } from "./feed-data-table/stack-view";
 export { activeStackIndex, sortStackItems } from "./feed-stack-controller";
 export type { StackSortPreference } from "./feed-stack-controller";
 export { PaneFooterScope, usePaneFooter } from "./layout/pane/footer";
+// The common footer shapes on top of `usePaneFooter`: a status segment that
+// changes with loading/error state, and one that also carries a link.
+export { usePaneStatusFooter, usePaneStatusLinkFooter } from "../plugins/builtin/shared/pane-footer";
+export { usePaneNoticeFooter, type UsePaneNoticeFooterOptions } from "./use-pane-notice-footer";
+export { loadingErrorFooterInfo } from "../plugins/builtin/shared/table-pane";
 export type { PaneFooterPressEvent, PaneFooterSegment, PaneHint } from "./layout/pane/footer";
 export {
   getPaneSidebarWidth,
@@ -42,19 +78,8 @@ export type {
   PaneSidebarRowRenderState,
 } from "./layout/pane/sidebar";
 export { useExternalLinkFooter } from "./use-external-link-footer";
-export { Button } from "./ui/button";
-export { Checkbox } from "./ui/checkbox";
-export { ConfirmDialog } from "./ui/confirm-dialog";
-export { ChoiceDialog } from "./ui/choice-dialog";
-export type { ChoiceDialogChoice } from "./ui/choice-dialog";
-export type { DataTableCell, DataTableColumn, DataTableVisibleRange } from "./ui/data-table";
-export { EmptyState, PaneStatusBody, loadingText, unavailableText } from "./ui/status";
-export { getMessageComposerBlockHeight, MessageComposer } from "./ui/message-composer";
-export { NumberField, TextField } from "./ui/fields";
-export { SegmentedControl } from "./ui/toggle";
-export { SelectButton } from "./ui/select-button";
-export type { SelectButtonOption, SelectButtonProps } from "./ui/select-button";
-export { Spinner } from "./ui/loading";
-export { RemoteImage } from "./ui";
-export { Tabs } from "./ui/tabs";
+// Markdown as the app renders it, for panes that show text written by someone
+// else: a model's answer, a release note, a fetched article.
+export { MarkdownText } from "./markdown-text";
+export * from "./ui";
 export { usePaneTicker } from "../state/app/context";

package/src/components/layout/detached-pane-shell.tsx

@@ -2,9 +2,10 @@ import { Box, Span, Text, useContextMenu, useRendererHost, useUiCapabilities } f
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { t } from "../../i18n";
 import { useShortcut, useViewport } from "../../react/input";
-import { resolveTickerForPane, useAppDispatch, useAppSelector } from "../../state/app/context";
+import { resolveTickerForPane, useAppDispatch, useAppSelector, usePaneAppConfig } from "../../state/app/context";
 import type { DesktopWindowBridge } from "../../types/desktop-window";
 import { findPaneInstance } from "../../types/config";
+import { isPaneLocked, PANE_LOCK_SETTING_KEY } from "../../pane-settings";
 import type { PluginRegistry } from "../../plugins/registry";
 import { floatingPaneBg, floatingPaneTitleBg, paneTitleText } from "../../theme/colors";
 import { useThemeColors } from "../../theme/theme-context";
@@ -14,13 +15,14 @@ import { PaneContent } from "./pane/content";
 import { resolvePaneBodyFrame, shouldReservePaneFooter } from "./pane/sizing";
 import { getPaneDisplayTitle } from "./pane/title";
 import { TITLEBAR_OVERLAY_HEIGHT_PX, getTitlebarLeadingInset } from "./titlebar-overlay";
+import { useWindowFullscreen } from "./window-fullscreen";
 import { WindowControls, WINDOWS_CONTROL_GROUP_WIDTH_PX } from "./window-controls";
 import {
   createDoubleEscapeCloseState,
   recordDoubleEscapeClose,
   resetDoubleEscapeClose,
 } from "../../utils/double-escape-close";
-import { createShare, openLiveShareUrl } from "../../shares/api";
+import { copyLivePaneShare } from "../../shares/live";
 import { buildPaneSharePayload } from "../../shares/pane";
 import type { ContextMenuItem } from "../../types/context-menu";
 import {
@@ -43,7 +45,7 @@ export function DetachedPaneShell({ pluginRegistry, desktopWindowBridge }: Detac
   const dispatch = useAppDispatch();
   const rendererHost = useRendererHost();
   const { showContextMenu } = useContextMenu();
-  const config = useAppSelector((state) => state.config);
+  const config = usePaneAppConfig();
   const paneState = useAppSelector((state) => state.paneState);
   const inputCaptured = useAppSelector((state) => state.inputCaptured);
   const doubleEscapeCloseRef = useRef(createDoubleEscapeCloseState());
@@ -60,22 +62,28 @@ export function DetachedPaneShell({ pluginRegistry, desktopWindowBridge }: Detac
     windowControls,
   } = useUiCapabilities();
   const showWindowControls = nativeWindowChrome && windowControls === "windows";
-  const titlebarLeadingInset = titleBarOverlay && nativeWindowChrome ? getTitlebarLeadingInset() : 0;
+  const windowFullscreen = useWindowFullscreen();
+  const titlebarLeadingInset = titleBarOverlay && nativeWindowChrome
+    ? getTitlebarLeadingInset({ windowFullscreen })
+    : 0;
   const instance = useAppSelector((state) => findPaneInstance(state.config.layout, desktopWindowBridge.paneId) ?? null);
+  const locked = isPaneLocked(instance);
   const paneDef = instance ? pluginRegistry.panes.get(instance.paneId) ?? null : null;
   const hasPaneSettings = !!instance && pluginRegistry.hasPaneSettings(instance.instanceId);
   const titleState = useMemo(
     () => ({ config, paneState }) as Parameters<typeof resolveTickerForPane>[0],
     [config, paneState],
   );
+  const tickers = useAppSelector((state) => state.tickers);
   const sharePayload = useMemo(() => instance && publicSharing
     ? buildPaneSharePayload(
         pluginRegistry,
         instance,
         paneState[instance.instanceId] ?? {},
         resolveTickerForPane(titleState, instance.instanceId),
+        tickers,
       )
-    : null, [instance, paneState, pluginRegistry, publicSharing, titleState]);
+    : null, [instance, paneState, pluginRegistry, publicSharing, tickers, titleState]);
   const quickSettings = instance ? pluginRegistry.resolvePaneQuickSettings(instance.instanceId) : [];
   const title = instance && paneDef
     ? getPaneDisplayTitle(titleState, instance, paneDef, pluginRegistry.panes)
@@ -117,7 +125,7 @@ export function DetachedPaneShell({ pluginRegistry, desktopWindowBridge }: Detac
       if (recordDoubleEscapeClose(doubleEscapeState, desktopWindowBridge.paneId, Date.now())) {
         event.preventDefault();
         event.stopPropagation();
-        void desktopWindowBridge.closeDetachedPane?.(desktopWindowBridge.paneId);
+        if (!locked) void desktopWindowBridge.closeDetachedPane?.(desktopWindowBridge.paneId);
       }
       return;
     }
@@ -128,8 +136,14 @@ export function DetachedPaneShell({ pluginRegistry, desktopWindowBridge }: Detac
   useShortcut((event) => {
     if (event.name !== "w" || (!event.ctrl && !event.meta && !event.super)) return;
     if (inputCaptured && event.ctrl && !event.meta && !event.super) return;
+    // Swallowed either way, so a locked pane never falls through to the
+    // window's own close accelerator.
     event.preventDefault();
     event.stopPropagation();
+    if (locked) {
+      pluginRegistry.notify({ body: "Pane is locked. Unlock it in pane settings.", type: "info" });
+      return;
+    }
     void desktopWindowBridge.closeDetachedPane?.(desktopWindowBridge.paneId);
   });
 
@@ -140,17 +154,18 @@ export function DetachedPaneShell({ pluginRegistry, desktopWindowBridge }: Detac
 
   const sharePane = useCallback(async () => {
     if (!sharePayload) return;
-    try {
-      const { id } = await createShare(sharePayload);
-      await rendererHost.copyText(openLiveShareUrl(id));
-      pluginRegistry.notify({ body: "Share link copied to clipboard", type: "success" });
-    } catch (error) {
-      pluginRegistry.notify({
-        body: error instanceof Error ? error.message : "Could not share this pane.",
-        type: "error",
-      });
-    }
+    await copyLivePaneShare(sharePayload, {
+      copyText: (text) => rendererHost.copyText(text),
+      notify: (notification) => { pluginRegistry.notify(notification); },
+    });
   }, [pluginRegistry, rendererHost, sharePayload]);
+  useEffect(() => {
+    const share = () => { void sharePane(); };
+    pluginRegistry.sharePaneFn = share;
+    return () => {
+      if (pluginRegistry.sharePaneFn === share) pluginRegistry.sharePaneFn = () => {};
+    };
+  }, [pluginRegistry, sharePane]);
 
   useShortcut((event) => {
     if (resolvePaneManagementShortcut(event) !== "share" || !sharePayload) return;
@@ -160,6 +175,19 @@ export function DetachedPaneShell({ pluginRegistry, desktopWindowBridge }: Detac
     void sharePane();
   });
 
+  const togglePaneLock = useCallback(() => {
+    void pluginRegistry.applyPaneSettingValueFn(
+      desktopWindowBridge.paneId,
+      { key: PANE_LOCK_SETTING_KEY, label: "Lock Pane", type: "toggle" },
+      !locked,
+    ).catch((error) => {
+      pluginRegistry.notify({
+        body: error instanceof Error ? error.message : "Could not update pane setting.",
+        type: "error",
+      });
+    });
+  }, [desktopWindowBridge.paneId, locked, pluginRegistry]);
+
   const openActions = useCallback((event?: { stopPropagation?: () => void; preventDefault?: () => void }) => {
     stopMouse(event);
     focusPane();
@@ -177,6 +205,12 @@ export function DetachedPaneShell({ pluginRegistry, desktopWindowBridge }: Detac
       accelerator: PANE_MANAGEMENT_ACCELERATORS.share,
       onSelect: sharePane,
     });
+    items.push({
+      id: "toggle-pane-lock",
+      // The label carries the state: the terminal menu has no checkmark column.
+      label: locked ? "Unlock Pane" : "Lock Pane",
+      onSelect: togglePaneLock,
+    });
     void showContextMenu({
       kind: "pane",
       paneId: desktopWindowBridge.paneId,
@@ -187,7 +221,7 @@ export function DetachedPaneShell({ pluginRegistry, desktopWindowBridge }: Detac
       if (!shown && hasPaneSettings) pluginRegistry.openPaneSettingsFn(desktopWindowBridge.paneId);
       else if (!shown && sharePayload) void sharePane();
     });
-  }, [desktopWindowBridge.paneId, focusPane, hasPaneSettings, instance?.paneId, pluginRegistry, sharePane, sharePayload, showContextMenu, title]);
+  }, [desktopWindowBridge.paneId, focusPane, hasPaneSettings, instance?.paneId, locked, pluginRegistry, sharePane, sharePayload, showContextMenu, title, togglePaneLock]);
   const toggleQuickSetting = useCallback((key: string, event?: { stopPropagation?: () => void; preventDefault?: () => void }) => {
     stopMouse(event);
     focusPane();
@@ -293,6 +327,26 @@ export function DetachedPaneShell({ pluginRegistry, desktopWindowBridge }: Detac
                   </Box>
                 ))}
                 <Box flexGrow={1} minWidth={0} />
+                {locked && (
+                  <Box
+                    height={1}
+                    minWidth={20}
+                    paddingLeft={1}
+                    paddingRight={1}
+                    alignItems="center"
+                    justifyContent="center"
+                    data-gloom-role="pane-lock"
+                    aria-label="Locked: the close shortcut leaves this pane open"
+                    title="Locked: the close shortcut leaves this pane open"
+                  >
+                    <Span style={{ display: "inline-flex", width: 12, height: 12, color: colors.textDim }}>
+                      <svg viewBox="0 0 12 12" width="12" height="12" fill="none" aria-hidden="true">
+                        <rect x="2.5" y="5.5" width="7" height="5" rx="1.2" fill="currentColor" />
+                        <path d="M4.25 5.5V4a1.75 1.75 0 0 1 3.5 0v1.5" stroke="currentColor" strokeWidth="1.2" strokeLinecap="round" />
+                      </svg>
+                    </Span>
+                  </Box>
+                )}
                 {(hasPaneSettings || sharePayload) && (
                   <Text
                     fg={paneTitleText(focused, true, colors)}