gloomberb 0.18.3 → 0.18.4

package/src/components/chart/composite/use-composite-value-scales.ts

@@ -0,0 +1,44 @@
+import { useCallback, useRef, useState } from "react";
+import type { CompositeAxisSide } from "./types";
+import { NO_VALUE_SCALES, valueScaleSlot, type CompositeValueRange, type CompositeValueScales } from "./value-scale";
+
+/**
+ * The chart's manual value scales: set by a drag or the wheel on an axis, or
+ * a drag on the plot of a panel already scaled by hand; cleared per panel or
+ * all at once, and whenever `resetKey` changes (in the same render, so a new
+ * view never draws in the old one's scale).
+ */
+export function useCompositeValueScales(resetKey: unknown) {
+  const [state, setState] = useState<{ resetKey: unknown; scales: CompositeValueScales }>(() => ({ resetKey, scales: NO_VALUE_SCALES }));
+  const resetKeyRef = useRef(resetKey);
+  resetKeyRef.current = resetKey;
+  const scales = Object.is(state.resetKey, resetKey) ? state.scales : NO_VALUE_SCALES;
+  const update = useCallback((change: (scales: CompositeValueScales) => CompositeValueScales) => {
+    setState((current) => {
+      const key = resetKeyRef.current;
+      const fresh = Object.is(current.resetKey, key);
+      const base = fresh ? current.scales : NO_VALUE_SCALES;
+      const next = change(base);
+      return fresh && next === base ? current : { resetKey: key, scales: next };
+    });
+  }, []);
+  const setValueScale = useCallback((panelId: string, side: CompositeAxisSide, key: string, range: CompositeValueRange) => {
+    const slot = valueScaleSlot(panelId, side);
+    update((current) => {
+      const previous = current[slot];
+      if (previous && previous.key === key && previous.min === range.min && previous.max === range.max) return current;
+      return { ...current, [slot]: { key, min: range.min, max: range.max } };
+    });
+  }, [update]);
+  const resetPanelValueScale = useCallback((panelId: string) => {
+    update((current) => {
+      const slots = (["left", "right"] as const).map((side) => valueScaleSlot(panelId, side)).filter((slot) => slot in current);
+      if (slots.length === 0) return current;
+      const next = { ...current };
+      for (const slot of slots) delete next[slot];
+      return Object.keys(next).length === 0 ? NO_VALUE_SCALES : next;
+    });
+  }, [update]);
+  const resetValueScales = useCallback(() => update(() => NO_VALUE_SCALES), [update]);
+  return { valueScales: scales, setValueScale, resetPanelValueScale, resetValueScales };
+}

package/src/components/chart/composite/use-composite-viewport.ts

@@ -99,9 +99,13 @@ export function useCompositeViewport({
     );
   }, [onViewportChange, userViewportEnd, userViewportStart]);
 
+  // Counts authored views, so what belongs to one (values scaled by hand) can
+  // go with it; `authoredViewportChanged` covers the render before it counts.
+  const [authoredGeneration, setAuthoredGeneration] = useState(0);
   useEffect(() => {
     previousAuthoredViewportRef.current = viewport ?? null;
     previousViewportResetKeyRef.current = viewportResetKey;
+    if (authoredViewportChanged) setAuthoredGeneration((generation) => generation + 1);
     if (authoredViewportChanged && userViewport) {
       viewportInteractionRef.current = "reset";
       setUserViewport(null);
@@ -154,8 +158,13 @@ export function useCompositeViewport({
     if (!positions) return;
     panViewport(shiftRatio * Math.max(positions.end - positions.start, Number.EPSILON));
   }, [effectiveViewport, navigationFrame, panViewport]);
-  const zoomViewport = useCallback((zoomFactor: number, anchorRatio = 1) => {
-    navigate("zoom", (base, frame) => zoomCompositeViewport(frame, base, zoomFactor, anchorRatio));
+  /** A gesture (a drag on the time axis) zooms from the view and frame it started in, by its whole travel so far. */
+  const zoomViewport = useCallback((
+    zoomFactor: number,
+    anchorRatio = 1,
+    gesture?: { frame: CompositeNavigationFrame; from: CompositeViewportRange },
+  ) => {
+    navigate("zoom", (base, frame) => zoomCompositeViewport(frame, base, zoomFactor, anchorRatio), gesture);
   }, [navigate]);
   const setViewportRange = useCallback((range: CompositeViewportRange) => {
     navigate("zoom", (_base, frame) => fitCompositeViewport(frame, range));
@@ -165,7 +174,7 @@ export function useCompositeViewport({
     setUserViewport(null);
   }, []);
   return {
-    navigationFrame, activeUserViewport, effectiveViewport,
+    navigationFrame, activeUserViewport, effectiveViewport, authoredViewportChanged, authoredGeneration,
     panViewport, panViewportByRatio, zoomViewport, setViewportRange, resetViewport,
   };
 }

package/src/components/chart/composite/value-scale.ts

@@ -0,0 +1,149 @@
+import type { PanelScale, ResolvedSeries } from "../../../time-series/types";
+import type { CompositeAxisSide } from "./types";
+import { clamp } from "../../../utils/math";
+
+/** What a value axis shows, in its own values. */
+export interface CompositeValueRange {
+  min: number;
+  max: number;
+}
+
+/**
+ * A value axis stretched or squeezed by hand, and what it plots: a range set
+ * for one listing's prices means nothing for another's, so it holds only
+ * while the axis plots the same series in the same unit and scale.
+ */
+export interface CompositeManualValueScale extends CompositeValueRange {
+  key: string;
+}
+
+/** Manual value scales by panel and side (`valueScaleSlot`). */
+export type CompositeValueScales = Readonly<Record<string, CompositeManualValueScale>>;
+
+export const NO_VALUE_SCALES: CompositeValueScales = Object.freeze({});
+
+export function valueScaleSlot(panelId: string, side: CompositeAxisSide): string {
+  return `${panelId}\u0000${side}`;
+}
+
+/** Identifies what an axis plots, for `CompositeManualValueScale.key`. */
+export function valueScaleKey(scale: PanelScale, axisSeries: readonly ResolvedSeries[]): string {
+  return [
+    scale,
+    ...axisSeries.map((entry) => [entry.id, entry.label, entry.unit, entry.listing?.symbol ?? ""].join("\u0001")),
+  ].join("\u0000");
+}
+
+/** Pixels of drag along an axis that stretch or squeeze it by a factor of e. */
+const AXIS_DRAG_PIXELS_PER_E = 200;
+/** The finest and coarsest a linear axis may get, against the size of the values it shows. */
+const MIN_LINEAR_SPAN_RATIO = 1e-9;
+const MAX_LINEAR_SPAN = 1e15;
+/** The same for a log axis, in natural-log units. */
+const MIN_LOG_SPAN = 1e-9;
+const MAX_LOG_SPAN = 60;
+
+/**
+ * How much a drag of `deltaPx` along an axis multiplies the span it shows.
+ * Down a value axis or right along the time axis shows more (a factor above
+ * one), the other way less, and the way back undoes it exactly.
+ */
+export function resolveAxisDragSpanFactor(deltaPx: number): number {
+  return Number.isFinite(deltaPx) ? Math.exp(deltaPx / AXIS_DRAG_PIXELS_PER_E) : 1;
+}
+
+function toAxis(value: number, scale: PanelScale): number {
+  return scale === "log" ? Math.log(value) : value;
+}
+
+function fromAxis(value: number, scale: PanelScale): number {
+  return scale === "log" ? Math.exp(value) : value;
+}
+
+/** The range as top and bottom in the axis's own space: values, or their logs. */
+function axisEnds(range: CompositeValueRange, scale: PanelScale): { top: number; bottom: number } | null {
+  if (scale === "log" && (range.min <= 0 || range.max <= 0)) return null;
+  const top = toAxis(range.max, scale);
+  const bottom = toAxis(range.min, scale);
+  return Number.isFinite(top) && Number.isFinite(bottom) && top > bottom ? { top, bottom } : null;
+}
+
+function rangeFromEnds(top: number, bottom: number, scale: PanelScale): CompositeValueRange {
+  return { min: fromAxis(bottom, scale), max: fromAxis(top, scale) };
+}
+
+/**
+ * The range after multiplying its span by `spanFactor` (above one shows more)
+ * around the value at `anchorRatio`, 0 the top of the panel and 1 the bottom,
+ * which stays where it is. A log axis stretches in its own, logarithmic space.
+ */
+export function zoomValueRange(
+  range: CompositeValueRange,
+  scale: PanelScale,
+  spanFactor: number,
+  anchorRatio: number,
+): CompositeValueRange {
+  const ends = axisEnds(range, scale);
+  if (!ends || !(spanFactor > 0) || !Number.isFinite(spanFactor)) return range;
+  const ratio = clamp(Number.isFinite(anchorRatio) ? anchorRatio : 0.5, 0, 1);
+  const span = ends.top - ends.bottom;
+  const anchor = ends.top - span * ratio;
+  const nextSpan = scale === "log"
+    ? clamp(span * spanFactor, MIN_LOG_SPAN, MAX_LOG_SPAN)
+    : clamp(span * spanFactor, Math.max(Math.abs(anchor), Number.MIN_VALUE) * MIN_LINEAR_SPAN_RATIO, MAX_LINEAR_SPAN);
+  const top = anchor + nextSpan * ratio;
+  return rangeFromEnds(top, top - nextSpan, scale);
+}
+
+/**
+ * The range moved with a drag of `deltaRatio` of the panel's height, positive
+ * downward: what was under the pointer stays under it.
+ */
+export function panValueRange(
+  range: CompositeValueRange,
+  scale: PanelScale,
+  deltaRatio: number,
+): CompositeValueRange {
+  const ends = axisEnds(range, scale);
+  if (!ends || !Number.isFinite(deltaRatio) || deltaRatio === 0) return range;
+  const shift = (ends.top - ends.bottom) * deltaRatio;
+  return rangeFromEnds(ends.top + shift, ends.bottom + shift, scale);
+}
+
+/** A manual range holds while some of the data is in it; pushed clear of the data it fits the data again. */
+export function manualValueRangeApplies(
+  manual: CompositeValueRange,
+  data: CompositeValueRange,
+  scale: PanelScale,
+): boolean {
+  const ends = axisEnds(manual, scale);
+  return !!ends && manual.max > data.min && manual.min < data.max;
+}
+
+/**
+ * Keeps an end of a segment that leaves the band from `minY` to `maxY` on the
+ * band's edge, along the segment: what is drawn of it inside stays exact and
+ * nothing is drawn far outside. Null when it misses the band.
+ */
+export function clipSegmentToBand(
+  x0: number,
+  y0: number,
+  x1: number,
+  y1: number,
+  minY: number,
+  maxY: number,
+): [number, number, number, number] | null {
+  if ((y0 < minY && y1 < minY) || (y0 > maxY && y1 > maxY)) return null;
+  if (y0 >= minY && y0 <= maxY && y1 >= minY && y1 <= maxY) return [x0, y0, x1, y1];
+  const at = (y: number) => {
+    const t = (y - y0) / (y1 - y0);
+    return x0 + (x1 - x0) * t;
+  };
+  let startX = x0;
+  let startY = y0;
+  let endX = x1;
+  let endY = y1;
+  if (startY < minY) { startX = at(minY); startY = minY; } else if (startY > maxY) { startX = at(maxY); startY = maxY; }
+  if (endY < minY) { endX = at(minY); endY = minY; } else if (endY > maxY) { endX = at(maxY); endY = maxY; }
+  return [startX, startY, endX, endY];
+}

package/src/components/chart/composite/volume-profile-paint.ts

@@ -27,7 +27,8 @@ export function paintVolumeProfile(
     row.volume > (profile.rows[best]?.volume ?? -1) ? index : best
   ), 0);
   profile.rows.forEach((row, index) => {
-    if (row.volume <= 0) return;
+    // Rows a hand-scaled axis leaves off the panel are not piled on its edge.
+    if (row.volume <= 0 || row.highRatio > 1 || row.lowRatio < 0) return;
     const top = Math.round(clamp(row.highRatio, 0, 1) * maxY);
     const edge = Math.round(clamp(row.lowRatio, 0, 1) * maxY);
     // A pixel between rows keeps tall bars apart; thin ones would vanish.
@@ -36,7 +37,8 @@ export function paintVolumeProfile(
     const opacity = index === pocRow ? POC_OPACITY : row.valueArea ? VALUE_AREA_OPACITY : OUTSIDE_OPACITY;
     fillRect(data, width, height, width - length, top, width - 1, bottom, color, opacity);
   });
-  const y = Math.round(clamp(profile.pocRatio, 0, 1) * maxY);
+  if (profile.pocRatio < 0 || profile.pocRatio > 1) return;
+  const y = Math.round(profile.pocRatio * maxY);
   for (let x = 0; x < width; x += 5) {
     fillRect(data, width, height, x, y, Math.min(x + 1, width - 1), y, color, 0.7);
   }
@@ -57,13 +59,14 @@ export function writeVolumeProfileText(
   const volumes = new Array<number>(height).fill(0);
   const valueArea = new Array<boolean>(height).fill(false);
   for (const row of profile.rows) {
+    if (row.highRatio > 1 || row.lowRatio < 0) continue;
     const line = clamp(Math.round(((row.highRatio + row.lowRatio) / 2) * (height - 1)), 0, height - 1);
     volumes[line]! += row.volume;
     if (row.valueArea) valueArea[line] = true;
   }
   const peak = Math.max(...volumes);
   if (peak <= 0) return;
-  const pocLine = clamp(Math.round(profile.pocRatio * (height - 1)), 0, height - 1);
+  const pocLine = profile.pocRatio < 0 || profile.pocRatio > 1 ? -1 : Math.round(profile.pocRatio * (height - 1));
   const maxLength = Math.max(1, Math.floor(width * PROFILE_WIDTH_RATIO));
   volumes.forEach((volume, line) => {
     if (volume <= 0) return;

package/src/components/chart/core/pointer.ts

@@ -21,6 +21,8 @@ export interface ChartMouseEvent {
   y: number;
   /** DOM target on the desktop host; absent in the terminal. */
   target?: { closest?: (selector: string) => unknown } | null;
+  /** The press's click count on the desktop host (2 on a double click); absent in the terminal. */
+  detail?: number;
   preciseX?: number;
   preciseY?: number;
   pixelX?: number;

package/src/components/chart-table/index.ts

@@ -6,6 +6,8 @@ export {
   fitChartTableColumns,
 } from "./layout";
 export type { ChartBandMode, ChartTableLayout } from "./layout";
+export { ChartRead, useChartReadRows } from "./read";
+export type { ChartReadProps } from "./read";
 export { useChartTableSelection } from "./selection";
 export type { ChartTableSelection } from "./selection";
 export { formatBpAxis, formatCompactAxis, formatPercentAxis, spanAxisFormatter, spanDigits } from "./axis";

package/src/components/chart-table/read.tsx

@@ -0,0 +1,74 @@
+import { useThemeColors } from "../../theme/theme-context";
+import { Box, Text, useUiCapabilities } from "../../ui";
+import { displayWidth, truncateToDisplayWidth } from "../../utils/format";
+import { wrapTextLines } from "../../utils/text-wrap";
+import { ClippedText } from "../ui/display";
+
+/** The terminal wraps a read onto at most this many rows; a longer one ends in an ellipsis on the last. */
+export const CHART_READ_MAX_ROWS = 3;
+/** The read's inset on each side, as on the query bar and the legend above it. */
+const READ_INSET = 1;
+
+/**
+ * The terminal's lines for a read under a chart at a pane `width`: the whole
+ * sentence on one row when it fits, otherwise wrapped at words onto up to
+ * `CHART_READ_MAX_ROWS` rows. None when there is no read or no room for one.
+ */
+export function chartReadLines(text: string | null | undefined, width: number): string[] {
+  const room = Math.floor(width) - 2 * READ_INSET;
+  const read = text?.trim();
+  if (!read || room <= 0) return [];
+  if (displayWidth(read) <= room) return [read];
+  const lines = wrapTextLines(read, room);
+  if (lines.length <= CHART_READ_MAX_ROWS) return lines;
+  return [
+    ...lines.slice(0, CHART_READ_MAX_ROWS - 1),
+    truncateToDisplayWidth(lines.slice(CHART_READ_MAX_ROWS - 1).join(" "), room),
+  ];
+}
+
+/**
+ * The rows the longest of these reads needs under a chart at a pane `width`
+ * (none when none has one). A pane puts it in `minRows` so the band does not
+ * flip between a chart and a strip as the selection moves between a short
+ * read and a long one. The desktop and the web cut a read by CSS on one row.
+ */
+export function useChartReadRows(texts: ReadonlyArray<string | null | undefined>, width: number): number {
+  const { nativePaneChrome } = useUiCapabilities();
+  let rows = 0;
+  for (const text of texts) {
+    const lines = chartReadLines(text, width).length;
+    rows = Math.max(rows, nativePaneChrome ? Math.min(1, lines) : lines);
+  }
+  return rows;
+}
+
+export interface ChartReadProps {
+  /** The plain sentence worked out from the numbers, as the server wrote it. */
+  text: string | null | undefined;
+  /** The pane's width: the read sits one cell in from each edge. */
+  width: number;
+}
+
+/**
+ * The plain read under a chart's axis. In the terminal the whole sentence is
+ * wrapped onto up to `CHART_READ_MAX_ROWS` rows (take its rows from the chart
+ * with `useChartReadRows`); the desktop and the web keep one row and cut it
+ * by CSS where its box ends.
+ */
+export function ChartRead({ text, width }: ChartReadProps) {
+  const colors = useThemeColors();
+  const { nativePaneChrome } = useUiCapabilities();
+  const lines = chartReadLines(text, width);
+  if (lines.length === 0) return null;
+  if (nativePaneChrome) {
+    return <Box height={1} paddingX={READ_INSET}><ClippedText fg={colors.textMuted} text={text!.trim()} width={width - 2 * READ_INSET} /></Box>;
+  }
+  return (
+    <Box flexDirection="column" height={lines.length} flexShrink={0}>
+      {lines.map((line, index) => (
+        <Box key={index} height={1} paddingX={READ_INSET}><Text fg={colors.textMuted}>{line}</Text></Box>
+      ))}
+    </Box>
+  );
+}

package/src/components/command-bar/commands/collection-list.ts

@@ -1,6 +1,8 @@
 import type { AppState } from "../../../state/app/context";
 import type { TickerRecord } from "../../../types/ticker";
 import { splitSymbolArgs, splitSymbolWords, symbolInputKey, uniqueSymbols } from "../../../cli/symbol-args";
+import { protectFigureCommas } from "../../../cli/symbol-cells";
+import { readSymbolList } from "../../../cli/symbol-list";
 import { readNameEntries } from "../../../cli/name-entries";
 import {
   addSymbols,
@@ -42,17 +44,17 @@ export interface PastedSymbolList {
 }
 
 /**
- * The entries of text typed or pasted after `AW`, split as `gloomberb quote`
+ * The entries of text typed or pasted after `AW`, split as `gloom quote`
  * splits its arguments (`splitSymbolArgs`): on commas, semicolons, tabs and
  * lines when it has them, where an entry with spaces may be a company's name
- * or several symbols, else on spaces. Null for one word or none, which keep
- * the single add. Spaces alone also separate a company's name (`Palo Alto
- * Networks`), which is why `separated` says when the text left no doubt it is
- * a list.
+ * or several symbols, else on spaces. A decimal comma (`2.582,52`) splits
+ * nothing. Null for one word or none, which keep the single add. Spaces alone
+ * also separate a company's name (`Palo Alto Networks`), which is why
+ * `separated` says when the text left no doubt it is a list.
  */
 export function pastedSymbolList(raw: string | undefined): PastedSymbolList | null {
   if (!raw || splitSymbolWords([raw]).length < 2) return null;
-  return { ...uniqueSymbols(splitSymbolArgs([raw])), separated: /[,;\t\r\n]/.test(raw) };
+  return { ...uniqueSymbols(splitSymbolArgs([raw])), separated: /[,;\t\r\n]/.test(protectFigureCommas(raw)) };
 }
 
 /**
@@ -86,30 +88,45 @@ function reasonLine(row: SymbolRow): string | null {
   if (row.hint && row.status === "added") return row.hint;
   // Another company had the symbol: say which, beside the listing added.
   if (row.changeNote && row.status === "added") return row.changeNote;
+  // Listed only abroad: the venue and currency it was added on.
+  if (row.abroad && row.status === "added") return row.abroad;
   if (row.readAs && (row.status === "added" || row.status === "already_listed")) return row.readAs;
   // Why the match was left out, and the symbol it trades as now when there is one.
   if (row.status === "needs_choice") return row.message ?? typed;
+  // Not a symbol, or not looked up: the summary names them, and the notice says what to do about the second.
   if (row.status !== "failed" && !(row.status === "not_found" && row.message && !NO_MATCH.test(row.message))) return null;
   const text = reason(row.message ?? "", typed);
   return text.includes(typed) ? text : `${typed}: ${text}`;
 }
 
+/** Rows that did not join the watchlist and say why, which keep the report up longer. */
+const UNRESOLVED = new Set<SymbolRow["status"]>(["not_found", "needs_choice", "failed", "not_a_symbol", "not_looked_up"]);
+
 /**
  * What a list add says, in the words the CLI's summary uses: the counts, the
  * symbols that found nothing or were not added, and under it the reason for
- * each that has one. Skipped symbols keep the report up longer.
+ * each that has one, what the reader left out (the prices beside the
+ * symbols, in one line), and one line for the symbols Gloom Cloud did not
+ * answer for. Skipped symbols keep the report up longer.
  */
 function describeListAdd(
   rows: readonly SymbolRow[],
   watchlistName: string,
   repeated: number,
+  notes: readonly string[] = [],
 ): { body: string; type: "success" | "info" | "error"; duration?: number } {
   const summary = `Watchlist "${watchlistName}": ${summarizeSymbolRows(rows, "add", repeated)}`;
   const reasons = rows.map(reasonLine).filter((line): line is string => !!line);
+  const unanswered = rows.filter((row) => row.status === "not_looked_up").length;
   const added = rows.some((row) => row.status === "added");
-  const unresolved = rows.some((row) => row.status === "not_found" || row.status === "needs_choice" || row.status === "failed");
+  const unresolved = rows.some((row) => UNRESOLVED.has(row.status));
   return {
-    body: [summary, ...reasons].join("\n"),
+    body: [
+      summary,
+      ...reasons,
+      ...notes,
+      ...unanswered > 0 ? [`Gloom Cloud did not answer for ${unanswered === 1 ? "one symbol" : `${unanswered} symbols`}; add ${unanswered === 1 ? "it" : "them"} again in a minute.`] : [],
+    ].join("\n"),
     type: added && !unresolved ? "success" : unresolved && !added ? "error" : "info",
     duration: unresolved ? SKIPPED_REPORT_MS : undefined,
   };
@@ -118,12 +135,14 @@ function describeListAdd(
 /**
  * A symbol typed to add on its own that a pasted list would leave for a
  * choice (`typedSymbolChoice`: its company moved or merged away, the match is
- * abroad or stopped trading) is not added either. The notice says why, and
- * what to add instead or to keep the match. Resolves true when it said so.
+ * abroad while the symbol names a US listing, or it stopped trading) is not
+ * added either. The notice says why, and what to add instead or to keep the
+ * match; `refused` says it did. One listed only abroad is added, and `abroad`
+ * is the line naming its venue and currency, for the add to say.
  */
-export async function refuseTypedChoice(rawInput: string, deps: SharedWorkflowDeps, notify: Notify): Promise<boolean> {
+export async function refuseTypedChoice(rawInput: string, deps: SharedWorkflowDeps, notify: Notify): Promise<{ refused: boolean; abroad: string | null }> {
   const row = await typedSymbolChoice(rawInput, deps.tickerRepository, deps.dataProvider);
-  if (!row) return false;
+  if (row?.status !== "needs_choice") return { refused: false, abroad: row?.abroad ?? null };
   const message = row.message ?? symbolInputKey(row.input);
   const offers = [
     ...row.tradesAs ? [`${row.tradesAs} for what it trades as now`] : [],
@@ -131,12 +150,12 @@ export async function refuseTypedChoice(rawInput: string, deps: SharedWorkflowDe
   ];
   notify([/[.!?]$/.test(message) ? message : `${message}.`, ...offers.length > 0 ? [`Add ${offers.join(", or ")}.`] : []].join("\n"),
     { type: "error", duration: SKIPPED_REPORT_MS });
-  return true;
+  return { refused: true, abroad: null };
 }
 
 /**
  * Adds every symbol of a pasted list to a watchlist in one step. Each symbol
- * resolves as `gloomberb watchlist add` resolves it (Gloom Cloud search and
+ * resolves as `gloom watchlist add` resolves it (Gloom Cloud search and
  * quote, the venue its own quote is on), except that a symbol several listings
  * carry is never given the first: it is left out and named, for the single add
  * to ask which. One that is unknown or already listed does not stop the rest.
@@ -159,10 +178,13 @@ export async function addPastedListToWatchlist(options: {
   const deps = options.buildWorkflowDeps();
   // Spaces alone also separate the words of a name, which belongs to search.
   if (!list.separated && await namesOneCompany(list.symbols, deps.dataProvider)) return false;
-  // An entry with spaces is a company's name search finds, or the symbols it holds.
-  const read = uniqueSymbols(await readNameEntries(list.symbols, deps.dataProvider));
+  // Read as `watchlist add` reads a list: an entry with spaces is a company's name search finds, or the symbols it
+  // holds, and a price beside a symbol (`ED 2.582,52`) is left out and named.
+  const read = await readSymbolList({
+    args: [options.rawInput], stdinPiped: false, readEntries: (entries) => readNameEntries(entries, deps.dataProvider),
+  });
   const symbols = read.symbols;
-  const repeated = list.repeated + read.repeated;
+  const repeated = read.repeated;
   const state = options.getState();
   const known = options.explicitTargetId && state.config.watchlists.some((entry) => entry.id === options.explicitTargetId)
     ? options.explicitTargetId
@@ -233,7 +255,7 @@ export async function addPastedListToWatchlist(options: {
       recordAttention(publicTickerKey(ticker.metadata.ticker, ticker.metadata.exchange), "watchlist_add");
     }
   }
-  const report = describeListAdd(rows, watchlistName, repeated);
+  const report = describeListAdd(rows, watchlistName, repeated, read.notes);
   notify(report.body, { type: report.type, duration: report.duration });
   options.closeAll({ revertThemePreview: false });
   return true;

package/src/components/command-bar/commands/collection.ts

@@ -62,8 +62,10 @@ export async function executeCollectionCommandAction(options: {
   });
   if (list?.separated && await addList(list)) return;
   // One typed symbol is decided as a symbol of a pasted list is: a match the list would leave for a choice is not added.
-  if (action === "add" && !options.selectedTicker && !list && options.rawInput?.trim()
-    && await refuseTypedChoice(options.rawInput, deps, options.notify)) {
+  const typed = action === "add" && !options.selectedTicker && !list && options.rawInput?.trim()
+    ? await refuseTypedChoice(options.rawInput, deps, options.notify)
+    : null;
+  if (typed?.refused) {
     options.closeAll({ revertThemePreview: false });
     return;
   }
@@ -246,7 +248,11 @@ export async function executeCollectionCommandAction(options: {
       `${action === "add" ? "Added" : "Removed"} ${resolvedTicker.symbol} ${action === "add" ? "to" : "from"} "${targetName}".`,
       { type: "success" },
     );
-    if (action === "add") notifyTickerChange(deps.dataProvider, resolvedTicker.ticker, options.notify);
+    if (action === "add") {
+      // Listed only abroad: the venue and currency it went to, as `watchlist add` says it.
+      if (typed?.abroad) options.notify(typed.abroad, { type: "info" });
+      notifyTickerChange(deps.dataProvider, resolvedTicker.ticker, options.notify);
+    }
   } else {
     options.notify(
       action === "add"

package/src/components/command-bar/commands/direct/index.ts

@@ -220,7 +220,7 @@ export function runDirectCommandAction(options: {
         title: "Reset All Data",
         body: [
           "This will permanently delete all portfolios, tickers, notes, broker credentials, and settings.",
-          "Gloomberb will quit and show the setup wizard on next launch.",
+          "Gloom will quit and show the setup wizard on next launch.",
         ],
         confirmLabel: "Reset Everything",
         cancelLabel: "Back",

package/src/components/command-bar/commands/direct/runtime.ts

@@ -81,12 +81,12 @@ export function useCommandBarDirectCommandRuntime({
   // A confirm it opens (Reset All Data) runs after the bar closed.
   const getState = useAppGetState();
   const rendererHost = useRendererHost();
-  const runSecurityDescriptionShortcut = useCallback(async (query?: string) => {
+  const runSecurityDescriptionShortcut = useCallback(async (query?: string, options?: { forceNewPane?: boolean }) => {
     const trimmed = query?.trim() || "";
     if (!trimmed) {
       const inferred = normalizeTickerInput(activeTickerSymbol, query);
       if (inferred) {
-        focusTicker(inferred);
+        focusTicker(inferred, options);
         closeAll({ revertThemePreview: false });
         return;
       }
@@ -103,6 +103,7 @@ export function useCommandBarDirectCommandRuntime({
     );
     if (resolvedTicker) {
       focusTicker(resolvedTicker.symbol, {
+        ...options,
         instrument: resolvedTicker.instrument,
         listing: resolvedTicker.listing,
       });