gloomberb 0.16.4 → 0.16.6

package/src/plugins/{builtin/plugin-marketplace → marketplace}/store.ts

@@ -1,4 +1,4 @@
-import type { LoadedExternalPlugin } from "../../loader";
+import type { LoadedExternalPlugin } from "../loader";
 import type { InstalledPlugin } from "./model";
 
 /**

package/src/plugins/registry/host-actions.ts

@@ -1,6 +1,8 @@
 import type { NewsCapability } from "../../capabilities";
 import type { PaneRuntimeState } from "../../core/state/app/state";
 import type { LayoutMarketplacePayload } from "../../shares/portable-layout";
+import type { PaneImageCapture } from "../../shares/pane-image";
+import type { DialogOptions, PromptContext } from "../../ui/dialog";
 import type { AppConfig, BrokerInstanceConfig, LayoutConfig } from "../../types/config";
 import type { TickerFinancials } from "../../types/financials";
 import type { NewsQuery, NewsQueryState } from "../../types/news-source";
@@ -42,6 +44,13 @@ export interface PluginHostActions {
   /** `options.fieldKey` starts the cursor on that setting, as a setting picked in the command bar does. */
   openPaneSettings(paneId?: string, options?: { fieldKey?: string }): void;
   sharePane(paneId?: string): void;
+  /**
+   * A picture of a pane (the focused one when omitted) as it looks now, its
+   * footer reading as a dated status line. Not on the plugin API.
+   */
+  capturePaneImage(paneId?: string): Promise<PaneImageCapture>;
+  /** Opens a dialog from code outside a React tree, such as a command or a menu item. Not on the plugin API. */
+  promptDialog<T>(options: DialogOptions<PromptContext<T>>): Promise<T | undefined>;
   openWindowMode(paneId?: string, mode?: WindowEditMode): void;
   /** The shell's fullscreen toggle for a pane; false when there is nothing to fill the window with. */
   togglePaneFullscreen(paneId: string): boolean;
@@ -105,6 +114,8 @@ export function createDefaultHostActions(current?: () => Pick<PluginHostActions,
     openBuiltInWorkflow: () => {},
     openPaneSettings: () => {},
     sharePane: () => {},
+    capturePaneImage: async () => { throw new Error("Pictures of panes are not available here."); },
+    promptDialog: async () => undefined,
     openWindowMode: () => {},
     togglePaneFullscreen: () => false,
     movePaneToNewLayout: () => false,

package/src/plugins/registry/index.ts

@@ -10,6 +10,14 @@ import {
   connectionHealth as sharedConnectionHealth,
   type ConnectionHealthRegistry,
 } from "../../core/connection-health";
+import { chartSeriesResolveRequestSchema } from "../../capabilities/chart-series";
+import {
+  registeredSeriesCapability,
+  resolveRegisteredSeries,
+  seriesCatalogCapability,
+} from "../../series/capability";
+import { SeriesRegistry } from "../../series/registry";
+import type { SeriesDefinition } from "../../series/types";
 import { cloudSyncController } from "../../sync/controller";
 import type {
   RegisteredSyncContributor,
@@ -83,6 +91,9 @@ interface PluginRegistryOptions {
 
 export type { WindowEditMode } from "./host-actions";
 
+/** The owner the series catalog capability is registered under; no plugin can switch it off. */
+const SERIES_CATALOG_OWNER = "gloomberb";
+
 /** A switched-off plugin, named for a "Turn on" offer. */
 export interface DisabledPluginOwner {
   id: string;
@@ -112,6 +123,9 @@ export class PluginRegistry implements PluginRuntimeAccess {
 
   readonly events: EventBus;
   readonly capabilities: CapabilityRegistry;
+  /** Every series plugins registered here: what the data catalog lists. */
+  readonly series: SeriesRegistry;
+  private readonly seriesNamespaceCapabilities = new Map<string, () => void>();
   readonly connectionHealth: ConnectionHealthRegistry;
   readonly marketData: DataProvider;
   readonly tickerRepository: AppTickerRepositoryPort;
@@ -136,11 +150,21 @@ export class PluginRegistry implements PluginRuntimeAccess {
     operationId: string,
     payload: unknown,
     options: { signal?: AbortSignal } = {},
-  ): Promise<T> => (
-    this.remoteCapabilityInvoke
+  ): Promise<T> => {
+    // A series registered in this process loads here, the desktop view
+    // included: its loaders fetch the way the panes that plot it do.
+    if (operationId === "resolve" && this.series.namespaceOwner(capabilityId)) {
+      const local = this.resolveLocalSeries(capabilityId, payload, options.signal);
+      if (local) return local as Promise<T>;
+    }
+    return this.remoteCapabilityInvoke
       ? this.remoteCapabilityInvoke<T>(capabilityId, operationId, payload, options)
-      : this.capabilities.invoke<T>(capabilityId, operationId, payload, { renderer: true, signal: options.signal })
-  );
+      : this.capabilities.invoke<T>(capabilityId, operationId, payload, { renderer: true, signal: options.signal });
+  };
+  /** True where capabilities run in another process (the desktop view), so a catalog asks that process too. */
+  get usesRemoteCapabilities(): boolean {
+    return !!this.remoteCapabilityInvoke;
+  }
   getBrokerAdapter = (brokerType: string) => this.contributions.brokersMap.get(brokerType) ?? null;
   listBrokerAdapters = () => [...this.contributions.brokersMap.values()];
 
@@ -186,6 +210,54 @@ export class PluginRegistry implements PluginRuntimeAccess {
       },
       connectionHealth: this.connectionHealth,
     });
+    this.series = new SeriesRegistry({
+      pluginHosts: (pluginId) => this.plugins.get(pluginId)?.hosts,
+      onNamespaceChange: (namespace, pluginId) => this.updateSeriesNamespace(namespace, pluginId),
+    });
+    if (this.enableCapabilityHandlers) {
+      this.capabilities.register(SERIES_CATALOG_OWNER, seriesCatalogCapability(this.series));
+    }
+  }
+
+  private resolveLocalSeries(namespace: string, payload: unknown, signal?: AbortSignal) {
+    const request = chartSeriesResolveRequestSchema.parse(payload);
+    const found = this.series.findLoaded(namespace, request.seriesId);
+    if (!found) return null;
+    if (this.getConfig().disabledPlugins.includes(found.series.pluginId)) {
+      const name = this.plugins.get(found.series.pluginId)?.name ?? found.series.pluginId;
+      return Promise.reject(new Error(`Turn on ${name} to chart ${found.series.definition.name}.`));
+    }
+    return resolveRegisteredSeries(this.series, namespace, request.seriesId, request.viewport, signal)
+      .then((resolved) => {
+        if (!resolved) throw new Error(`No series ${namespace}:${request.seriesId} is registered.`);
+        return resolved;
+      });
+  }
+
+  /** Gives a namespace with loaded series its chart-series capability, for automation and other processes. */
+  private updateSeriesNamespace(namespace: string, pluginId: string | null): void {
+    this.seriesNamespaceCapabilities.get(namespace)?.();
+    this.seriesNamespaceCapabilities.delete(namespace);
+    if (!pluginId || !this.enableCapabilityHandlers) return;
+    try {
+      this.seriesNamespaceCapabilities.set(namespace, this.capabilities.register(
+        pluginId,
+        registeredSeriesCapability(this.series, namespace),
+      ));
+    } catch (error) {
+      // A capability of the same id already answers there; the series still resolve in this process.
+      this.registryLog.warn("Series namespace has no capability", {
+        namespace,
+        pluginId,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }
+
+  private registerSeriesForPlugin(pluginId: string, series: SeriesDefinition, items: PluginItems): () => void {
+    const dispose = this.series.register(pluginId, series);
+    items.capabilityDisposers.push(dispose);
+    return dispose;
   }
 
   /**
@@ -526,6 +598,7 @@ export class PluginRegistry implements PluginRuntimeAccess {
       registerShortcut: (shortcut) => contributions.registerShortcut(pluginId, shortcut),
       registerTickerAction: (action) => contributions.registerTickerAction(pluginId, action),
       registerContextMenuProvider: (provider) => contributions.registerContextMenuProvider(pluginId, provider),
+      registerSeries: (series) => this.registerSeriesForPlugin(pluginId, series, items),
       registerSyncContributor: (contributor) => {
         const dispose = this.registerSyncContributorForPlugin(pluginId, contributor);
         items.eventDisposers.push(dispose);
@@ -615,6 +688,18 @@ export class PluginRegistry implements PluginRuntimeAccess {
         }
       }
 
+      for (const series of plugin.series ?? []) {
+        try {
+          this.registerSeriesForPlugin(plugin.id, series, items);
+        } catch (error) {
+          // One bad entry in a long list leaves the plugin's other series and panes working.
+          this.registryLog.error("Series skipped", {
+            pluginId: plugin.id,
+            error: error instanceof Error ? error.message : String(error),
+          });
+        }
+      }
+
       this.slots.register(plugin, (renderer) => withPluginRender(this.stateNamespace(plugin.id), this, renderer));
 
       const setupCommand = createPluginSetupCommand(plugin, {

package/src/portfolio/collection-name.ts

@@ -0,0 +1,31 @@
+/** Collections an unknown-name error lists, so the caller can retry with one. */
+const LISTED_COLLECTIONS = 12;
+
+/**
+ * The portfolio or watchlist an argument names, by its id or its name,
+ * trimmed and in any case: `Family`, `family` and `FAMILY` are one portfolio.
+ * An exact id wins over another collection's name. Every command and function
+ * that takes a portfolio or watchlist argument reads it here.
+ */
+export function findNamedCollection<T extends { id: string; name: string }>(
+  collections: readonly T[],
+  raw: string | null | undefined,
+): T | null {
+  const wanted = raw?.trim() ?? "";
+  if (!wanted) return null;
+  const exact = collections.find((entry) => entry.id === wanted);
+  if (exact) return exact;
+  const normalized = wanted.toLowerCase();
+  return collections.find((entry) => (
+    entry.id.toLowerCase() === normalized || entry.name.trim().toLowerCase() === normalized
+  )) ?? null;
+}
+
+/** "Main Portfolio (main), Family (family)": each collection's name and id, for an error naming what there is. */
+export function describeCollections(collections: readonly { id: string; name: string }[]): string {
+  const listed = collections.slice(0, LISTED_COLLECTIONS).map(({ id, name }) => (
+    name.trim() && name.trim() !== id ? `${name.trim()} (${id})` : id
+  ));
+  const more = collections.length - LISTED_COLLECTIONS;
+  return `${listed.join(", ")}${more > 0 ? ` and ${more} more` : ""}`;
+}

package/src/{plugins/builtin/portfolio-list → portfolio}/position-metrics.ts

@@ -1,9 +1,9 @@
-import type { TickerRecord } from "../../../types/ticker";
-import type { Quote } from "../../../types/financials";
-import type { PriceBasis } from "../../../types/instrument";
-import { resolvePriceBasis } from "../../../market-data/market/price-basis";
-import { getActiveQuoteDisplay, type ActiveQuoteDisplay } from "../../../market-data/market/status";
-import { resolveCurrencyUnit } from "../../../utils/currency-units";
+import type { TickerRecord } from "../types/ticker";
+import type { Quote } from "../types/financials";
+import type { PriceBasis } from "../types/instrument";
+import { resolvePriceBasis } from "../market-data/market/price-basis";
+import { getActiveQuoteDisplay, type ActiveQuoteDisplay } from "../market-data/market/status";
+import { resolveCurrencyUnit } from "../utils/currency-units";
 
 export interface PortfolioPositionMetrics {
   positionCurrency: string;

package/src/portfolio/position-value.ts

@@ -0,0 +1,40 @@
+import type { TickerFinancials } from "../types/financials";
+import type { TickerRecord } from "../types/ticker";
+import { convertCurrency } from "../utils/format";
+import { getPortfolioPositionMetrics, getPortfolioQuoteDisplay, resolvePortfolioMarketValue } from "./position-metrics";
+
+export function getPortfolioPositionValue({
+  ticker,
+  financials,
+  portfolioId,
+  baseCurrency,
+  exchangeRates,
+}: {
+  ticker: TickerRecord | null;
+  financials: TickerFinancials | null;
+  portfolioId: string | null;
+  baseCurrency: string;
+  exchangeRates: Map<string, number>;
+}): number {
+  if (!ticker) return 0;
+  const scopedTicker: TickerRecord = portfolioId
+    ? {
+        ...ticker,
+        metadata: {
+          ...ticker.metadata,
+          positions: ticker.metadata.positions.filter((position) => position.portfolio === portfolioId),
+        },
+      }
+    : ticker;
+  const quote = financials?.quote;
+
+  const quoteCurrency = quote?.currency || ticker.metadata.currency || baseCurrency;
+  const metrics = getPortfolioPositionMetrics(scopedTicker, undefined, quoteCurrency, {
+    currency: baseCurrency, convert: (value, currency) => convertCurrency(value, currency, baseCurrency, exchangeRates),
+  }, quote);
+  const activeQuote = getPortfolioQuoteDisplay(metrics, quote);
+
+  return resolvePortfolioMarketValue(metrics, activeQuote
+    ? convertCurrency(activeQuote.price, quoteCurrency, baseCurrency, exchangeRates) : null)?.gross
+    ?? (metrics.positionCount > 0 ? Number.NaN : 0);
+}

package/src/portfolio/valuation-basis.ts

@@ -0,0 +1,79 @@
+import type { Quote } from "../types/financials";
+import { latestRegularSessionClose } from "../market-data/market/freshness";
+import { getCompletedRegularSessionDisplay, type ActiveQuoteDisplay } from "../market-data/market/status";
+import { quoteTradingDay } from "../market-data/quotes/day-range";
+import type { ReportTime } from "../utils/utc-time";
+import { getPortfolioQuoteDisplay, type PortfolioPositionMetrics } from "./position-metrics";
+
+/**
+ * What a portfolio's market value is priced at. `latest-print` (the default,
+ * as brokers value a book) takes the last trade, pre-market and after hours
+ * included. `regular-close` takes the price Last shows: the regular session's
+ * close once it is over, so a value is Last times the shares.
+ */
+export type PortfolioValuationBasis = "latest-print" | "regular-close";
+
+/** The basis as reports and panes state it, after "Priced at". */
+export const VALUATION_BASIS_LABELS: Record<PortfolioValuationBasis, string> = {
+  "latest-print": "the latest print, extended hours included",
+  "regular-close": "the regular close",
+};
+
+/** Whether the regular close values this position: an option keeps its mark on either basis. */
+function valuesAtClose(metrics: Pick<PortfolioPositionMetrics, "valuesAtMark"> | null, basis: PortfolioValuationBasis): boolean {
+  return basis === "regular-close" && !metrics?.valuesAtMark;
+}
+
+/**
+ * The price a position is valued at on `basis`. The latest print is
+ * getPortfolioQuoteDisplay's. The regular close is the completed regular
+ * session's close and its move (getCompletedRegularSessionDisplay), the
+ * headline Last and Chg show, and the live price while that session trades.
+ */
+export function getPortfolioValuationDisplay(
+  metrics: PortfolioPositionMetrics,
+  quote: Quote | null | undefined,
+  basis: PortfolioValuationBasis = "latest-print",
+): ActiveQuoteDisplay | null {
+  const live = getPortfolioQuoteDisplay(metrics, quote);
+  if (!live || !valuesAtClose(metrics, basis)) return live;
+  return getCompletedRegularSessionDisplay(quote) ?? live;
+}
+
+/**
+ * When the completed regular session the quote reports closed: the venue's
+ * close on that day from its calendar, or the day alone when the calendar does
+ * not give the hour.
+ */
+function regularCloseTime(quote: Quote): ReportTime | null {
+  const date = quote.regularCloseSessionDate ?? quoteTradingDay(quote);
+  const exchange = quote.listingExchangeName || quote.exchangeName;
+  const close = exchange && Number.isFinite(quote.lastUpdated) ? latestRegularSessionClose(exchange, quote.lastUpdated) : null;
+  if (close && (!date || close.date === date)) return { time: close.close, dateOnly: false };
+  const day = date ? Date.parse(`${date}T00:00:00Z`) : Number.NaN;
+  return Number.isFinite(day) ? { time: day, dateOnly: true } : null;
+}
+
+/**
+ * When the price a position is valued at on `basis` is from: the quote's time
+ * for a print, the session's close for a regular close. Null without a dated quote.
+ */
+export function getPortfolioValuationTime(
+  quote: Quote | null | undefined,
+  basis: PortfolioValuationBasis = "latest-print",
+  metrics: Pick<PortfolioPositionMetrics, "valuesAtMark"> | null = null,
+): ReportTime | null {
+  if (!quote) return null;
+  if (valuesAtClose(metrics, basis) && getCompletedRegularSessionDisplay(quote)) {
+    const close = regularCloseTime(quote);
+    if (close) return close;
+  }
+  return Number.isFinite(quote.lastUpdated) && quote.lastUpdated > 0 ? { time: quote.lastUpdated, dateOnly: false } : null;
+}
+
+/** A valuation time as exports write it: an ISO instant in UTC, or an ISO date. */
+export function valuationTimeIso(time: ReportTime | null): string | null {
+  if (!time) return null;
+  const iso = new Date(time.time).toISOString();
+  return time.dateOnly ? iso.slice(0, 10) : iso;
+}

package/src/public/__snapshots__/public-api.test.ts.snap

@@ -367,9 +367,12 @@ exports[`the runtime exports of every public subpath are the reviewed ones 1`] =
     "CHART_RESOLUTION_STEP_MS",
     "CHART_SPEC_VERSION",
     "DEFAULT_CHART_RESOLUTION_SUPPORT",
+    "SERIES_FREQUENCIES",
     "TIME_RANGES",
     "TIME_RANGE_ORDER",
     "clampTimeRangeToMaxRange",
+    "defineSeries",
+    "describeSeriesUnits",
     "getBestSupportedResolutionForVisibleWindow",
     "getChartResolutionLabel",
     "getExpandedBufferRange",
@@ -378,12 +381,16 @@ exports[`the runtime exports of every public subpath are the reviewed ones 1`] =
     "getSupportMaxRange",
     "getSupportedChartResolutionsForViewport",
     "getSupportedPresetResolution",
+    "inferSeriesFrequency",
     "intersectChartResolutionSupport",
     "isIntradayResolution",
     "isRangePresetSupported",
+    "isValidSeriesUnit",
     "normalizeChartResolution",
     "normalizeChartResolutionSupport",
+    "parseSeriesCsv",
     "sortChartResolutions",
+    "validateSeriesDefinition",
   ],
   "./types/broker": [
     "resolveBrokerConfigFields",

package/src/public/time-series.ts

@@ -38,3 +38,20 @@ export type {
   SecuritySeriesSource, SeriesAxis, SeriesDataShape, SeriesInterpolation, SeriesPeriod, SeriesStyle,
   SeriesTimestampMode, SeriesTransform, TimeSeriesFieldDefinition, TimeSeriesPoint,
 } from "../time-series/types";
+
+// Series a plugin adds to the data catalog, chartable against any other
+// catalog entry: `series` on the plugin, or `ctx.registerSeries` from setup.
+// PLUGINS.md ("Data catalog series") shows both, and series from a file.
+export {
+  defineSeries, describeSeriesUnits, isValidSeriesUnit, SERIES_FREQUENCIES, validateSeriesDefinition,
+} from "../series/validate";
+export {
+  inferSeriesFrequency, parseSeriesCsv,
+} from "../series/csv";
+export type {
+  ParsedSeriesCsv, SeriesCsvColumn, SeriesCsvMetadata,
+} from "../series/csv";
+export type {
+  ExpressionSeriesDefinition, LoadedSeriesDefinition, SeriesDefinition, SeriesDrawStyle, SeriesFrequency,
+  SeriesAttribution, SeriesInput, SeriesLoadOutput, SeriesLoadRequest, SeriesLoadResult, SeriesPoint,
+} from "../series/types";

package/src/react/auto-refresh.ts

@@ -13,17 +13,27 @@ export const AGE_TICK_MS = 30_000;
  * rests while the pane cannot be seen and catches up when it can.
  */
 export function useUpdatedAgo(lastUpdated: number | null): string | null {
+  const now = useAgeClock(lastUpdated);
+  return lastUpdated ? formatRelativeAge(lastUpdated, now) : null;
+}
+
+/**
+ * The time a label that says how old data is reads against: it moves every
+ * `AGE_TICK_MS` once the data has loaded (`since`, restarting when it
+ * reloads), and rests while the pane cannot be seen.
+ */
+export function useAgeClock(since: number | null): number {
   const visible = usePaneVisible();
   const [now, setNow] = useState(() => Date.now());
 
   useEffect(() => {
-    if (!lastUpdated || !visible) return;
+    if (!since || !visible) return;
     setNow(Date.now());
     const timer = setInterval(() => setNow(Date.now()), AGE_TICK_MS);
     return () => clearInterval(timer);
-  }, [lastUpdated, visible]);
+  }, [since, visible]);
 
-  return lastUpdated ? formatRelativeAge(lastUpdated, now) : null;
+  return now;
 }
 
 export interface AutoRefreshOptions {

package/src/react/input.ts

@@ -6,6 +6,7 @@ import {
   useRef,
   type ReactNode,
 } from "react";
+import { keySignature, mayRepeat } from "./key-repeat";
 
 export interface KeyEventLike {
   key: string;
@@ -17,6 +18,12 @@ export interface KeyEventLike {
   meta: boolean;
   super?: boolean;
   targetEditable?: boolean;
+  /**
+   * The platform sent this press because the key is held down (DOM `repeat`,
+   * the kitty protocol's repeat event). Absent where the host cannot tell,
+   * such as a terminal that does not report event types.
+   */
+  readonly repeat?: boolean;
   readonly defaultPrevented?: boolean;
   readonly propagationStopped?: boolean;
   preventDefault(): void;
@@ -104,7 +111,7 @@ export function createShortcutRegistry({ flushSync }: ShortcutRegistryOptions =
   const entries = new Map<number, ShortcutEntry>();
   const beforeListeners = new Set<(event: KeyEventLike) => void>();
 
-  return {
+  const registry: ShortcutRegistry = {
     register(registration) {
       const order = nextOrder++;
       entries.set(order, {
@@ -153,6 +160,31 @@ export function createShortcutRegistry({ flushSync }: ShortcutRegistryOptions =
       }
     },
   };
+
+  // A held key repeats its press. Only the keys meant to repeat (key-repeat.ts)
+  // reach the handlers again; the rest already ran when the key went down.
+  // `lastPress` is that press: a repeat of a key the app claimed stays claimed,
+  // or the webview would act on it itself (a beep on macOS).
+  let lastPress: { signature: string; claimed: boolean } | null = null;
+  return {
+    ...registry,
+    dispatch(event) {
+      if (event.repeat === true && !mayRepeat(event)) {
+        if (lastPress?.claimed && lastPress.signature === keySignature(event)) {
+          event.preventDefault();
+          event.stopPropagation();
+        }
+        return;
+      }
+      registry.dispatch(event);
+      if (event.repeat !== true) {
+        lastPress = {
+          signature: keySignature(event),
+          claimed: event.defaultPrevented === true || event.propagationStopped === true,
+        };
+      }
+    },
+  };
 }
 
 export function useRegisteredShortcut(

package/src/react/key-repeat.ts

@@ -0,0 +1,86 @@
+import type { KeyEventLike } from "./input";
+
+type RepeatKey = Pick<KeyEventLike, "name" | "key" | "ctrl" | "meta" | "super" | "shift" | "alt" | "targetEditable">;
+
+/**
+ * Holding a key makes the platform send it again about thirty times a second
+ * (`repeat` on a DOM key event, the repeat event type of the kitty keyboard
+ * protocol). Most of what a key does should happen once per press, so the
+ * shortcut registry drops a repeat before any handler sees it unless the key
+ * is meant to repeat.
+ *
+ * Only keys that run a command are held to that: a command chord (Ctrl, Cmd or
+ * Super with a key), Escape, a function key and the menu key. Letters,
+ * digits, Enter, Space and the other plain keys pass untouched, because a pane
+ * binds them for typing, stepping and zooming (j and k, + and -, [ and ]) and
+ * nothing here can tell those from a one-shot. The core actions bound to a
+ * plain key (help, refresh, the pane menu) fire once through the cooldown on
+ * their own handlers instead.
+ *
+ * A command key repeats when it is on the allow-list below.
+ */
+
+/** Move, scroll, select and delete, with any modifier: Ctrl+Left, Cmd+Backspace, Shift+Down. */
+const REPEATING_KEY_NAMES: ReadonlySet<string> = new Set([
+  "up",
+  "down",
+  "left",
+  "right",
+  "pageup",
+  "pagedown",
+  "home",
+  "end",
+  "tab",
+  "backspace",
+  "delete",
+]);
+
+/** Ctrl+N and Ctrl+P step a list selection; they are the arrow keys of a terminal. */
+const LIST_STEP_LETTERS: ReadonlySet<string> = new Set(["n", "p"]);
+
+/** The editing chords of a text field: delete word, line, character, kill and yank. Ctrl only, and only in a field. */
+const FIELD_EDIT_LETTERS: ReadonlySet<string> = new Set(["a", "b", "d", "e", "f", "h", "k", "u", "w", "y"]);
+
+function keyName(event: Pick<KeyEventLike, "name" | "key">): string {
+  return (event.name ?? event.key ?? "").toLowerCase();
+}
+
+function isCommandKey(event: RepeatKey, name: string): boolean {
+  if (event.ctrl || event.meta || event.super === true) return true;
+  return name === "escape" || name === "esc" || name === "contextmenu" || name === "menu" || /^f([1-9]|1\d|2[0-4])$/.test(name);
+}
+
+/** Whether a held key keeps firing: true for typing and moving, false for a command that should run once. */
+export function mayRepeat(event: RepeatKey): boolean {
+  const name = keyName(event);
+  if (!isCommandKey(event, name)) return true;
+  if (REPEATING_KEY_NAMES.has(name)) return true;
+  const ctrlOnly = event.ctrl && !event.meta && event.super !== true && !event.alt && !event.shift;
+  if (!ctrlOnly) return false;
+  if (LIST_STEP_LETTERS.has(name)) return true;
+  return event.targetEditable === true && FIELD_EDIT_LETTERS.has(name);
+}
+
+/**
+ * Plain keys a pane's footer hint keeps repeating: moving, paging, stepping and
+ * zooming (`[` `]` `<` `>` `+` `-` `=`, and the vim letters). Any other hint key
+ * (an add, an export, a pause on Space) runs once per press: the footer drops
+ * its repeats, so a held key never opens a dialog or writes a file again.
+ */
+const REPEATING_HINT_KEYS: ReadonlySet<string> = new Set([
+  ...REPEATING_KEY_NAMES,
+  "j", "k", "h", "l",
+  "[", "]", "<", ">", "+", "-", "=", "_",
+]);
+
+/** Whether a held key keeps pressing the footer hint it names. Chords follow `mayRepeat`; plain keys must be a movement or zoom key. */
+export function hintMayRepeat(event: RepeatKey): boolean {
+  const name = keyName(event);
+  return isCommandKey(event, name) ? mayRepeat(event) : REPEATING_HINT_KEYS.has(name);
+}
+
+/** The key and its modifiers, to tell whether a repeat belongs to the press that came before it. */
+export function keySignature(event: RepeatKey): string {
+  const modifiers = [event.ctrl, event.alt, event.meta, event.shift, event.super === true].map(Number).join("");
+  return `${modifiers}:${keyName(event)}`;
+}

package/src/remote/app-host.tsx

@@ -1,13 +1,17 @@
-import { createContext, useContext, useEffect, useMemo } from "react";
+import { createContext, useContext, useEffect, useMemo, useRef } from "react";
 import type { Dispatch, ReactNode } from "react";
 import type { PluginRegistry } from "../plugins/registry";
 import type { AppAction, AppState } from "../state/app/context";
 import type { DesktopWindowBridge } from "../types/desktop-window";
+import { useOptionalDialog } from "../ui/dialog";
+import { confirmRemoteChange } from "./confirm-change";
 import { createAppRemoteController } from "./controller";
 import { useRemoteUiRegistry } from "./semantic-tree";
-import type { RemoteControlRequest, RemoteControlResponse } from "./types";
+import type { CapturePane } from "./pane-screenshot";
+import type { RemoteCallContext, RemoteControlRequest, RemoteControlResponse } from "./types";
 
-export type RemoteControlHandler = (request: RemoteControlRequest) => Promise<RemoteControlResponse>;
+/** `context` is for callers inside this process; the local endpoint sends requests alone. */
+export type RemoteControlHandler = (request: RemoteControlRequest, context?: RemoteCallContext) => Promise<RemoteControlResponse>;
 
 const RemoteControlHandlerContext = createContext<RemoteControlHandler | null>(null);
 
@@ -28,6 +32,8 @@ export interface RemoteControlAdapter {
    * kind of app it is and the machine name it shows under.
    */
   terminalDevice?: { kind: "desktop" | "tui"; name: string };
+  /** Paints a pane of this window for pane.screenshot; only the desktop app has one. */
+  capturePane?: CapturePane;
 }
 
 interface RemoteControlHostProps {
@@ -48,12 +54,22 @@ export function RemoteControlHost({
   desktopWindowBridge,
 }: RemoteControlHostProps) {
   const uiRegistry = useRemoteUiRegistry();
+  // Read at call time, so a new dialog host never restarts the server.
+  const dialog = useOptionalDialog();
+  const dialogRef = useRef(dialog);
+  dialogRef.current = dialog;
   const controller = useMemo(() => createAppRemoteController({
     dispatch,
     getState,
     pluginRegistry,
     uiRegistry,
     desktopWindowBridge,
+    capturePane: adapter?.capturePane,
+    confirmChange: async (prompt, signal) => {
+      const host = dialogRef.current;
+      if (!host) throw new Error("This window cannot ask for confirmation, so nothing changed.");
+      return confirmRemoteChange(host, prompt, signal);
+    },
     afterMutation: async () => {
       await Promise.resolve();
       await new Promise((resolve) => {
@@ -70,7 +86,7 @@ export function RemoteControlHost({
       });
       await new Promise((resolve) => setTimeout(resolve, 0));
     },
-  }), [desktopWindowBridge, dispatch, getState, pluginRegistry, uiRegistry]);
+  }), [adapter?.capturePane, desktopWindowBridge, dispatch, getState, pluginRegistry, uiRegistry]);
   const dataDir = getState().config.dataDir;
 
   useEffect(() => {