@gloom-sh/terminal 0.18.5 → 0.19.0

package/src/components/chart/composite/tools.ts

@@ -1,8 +1,8 @@
 import { formatPercentRaw } from "../../../utils/format";
 import type { ChartVectorShape } from "../../../ui/host";
 import type { NativeChartBitmap } from "../native/chart-rasterizer";
-import { drawCircle, drawLine, fillRect, parseHex } from "../native/raster/primitives";
-import { formatCompositeAxisValue, formatCompositeCursorDate } from "./format";
+import { drawCircle, drawLine, fillRect, parseHex, type RgbaColor } from "../native/raster/primitives";
+import { formatCompositeAxisValue, formatCompositeCursorDate, formatCompositeCursorValue } from "./format";
 import { projectCompositeValue, unprojectCompositeValue } from "./scene";
 import { projectCompositeTimestamp, unprojectCompositeTimestamp } from "./time-scale";
 import type {
@@ -13,7 +13,14 @@ import type {
 import { clamp } from "../../../utils/math";
 
 /** Pointer tools that take the drag away from panning while one is picked. */
-export type ChartToolKind = "measure" | "zoom" | "line" | "pencil" | "level";
+export type ChartToolKind = "measure" | "zoom" | "line" | "pencil" | "level" | "rect" | "fib" | "ray";
+
+/** How a saved drawing is drawn from its points. */
+export type ChartDrawingShape = "line" | "rect" | "fib" | "ray";
+const SHAPED_TOOLS = ["rect", "fib", "ray"] as const;
+
+/** Retracement ratios, measured back from the drag's end toward its start. */
+const FIB_LEVELS = [0, 0.236, 0.382, 0.5, 0.618, 0.786, 1] as const;
 
 export interface ChartDrawingPoint {
   time: number;
@@ -77,6 +84,18 @@ export function parseChartDrawings(value: unknown): ChartDrawing[] {
   return drawings;
 }
 
+/**
+ * The shape rides in the id (`fib:3`) rather than a field of its own: an older
+ * build refuses a saved drawing with a key it does not know and would drop every
+ * drawing of the pane, while an id it does not know still draws as a line.
+ */
+export function chartDrawingShape(drawing: Pick<ChartDrawing, "id" | "points">): ChartDrawingShape {
+  const prefix = drawing.id.slice(0, Math.max(0, drawing.id.indexOf(":")));
+  return drawing.points.length === 2 && (SHAPED_TOOLS as readonly string[]).includes(prefix)
+    ? prefix as ChartDrawingShape
+    : "line";
+}
+
 export interface ChartDrawingHit {
   drawing: ChartDrawing;
   /** Grabbed endpoint, or null when the whole shape was grabbed. */
@@ -119,7 +138,7 @@ const HOUR_MS = 60 * MINUTE_MS;
 const DAY_MS = 24 * HOUR_MS;
 
 function drawingPointFrom(
-  scene: CompositeChartScene,
+  scene: Pick<CompositeChartScene, "timeScale">,
   domain: CompositeAxisDomain,
   xRatio: number,
   yRatio: number,
@@ -132,14 +151,23 @@ function drawingPointFrom(
 
 /** Data anchors for a finished drag, so a drawing survives pan and zoom. */
 export function resolveDrawingFromDrag(
-  scene: CompositeChartScene,
+  scene: Pick<CompositeChartScene, "timeScale">,
   panel: CompositePanelScene,
   drag: ChartToolDrag,
   color: string,
   id: string,
 ): ChartDrawing | null {
   const domain = resolveMeasureAxisDomain(panel);
-  if (!domain || !isMeaningfulToolDrag(drag)) return null;
+  // A ray needs only its price, so a click places one.
+  if (!domain || (drag.kind !== "ray" && !isMeaningfulToolDrag(drag))) return null;
+  if (isShapedTool(drag.kind)) {
+    // A ray holds its first price, so its stored end is level with it and an
+    // older build draws the same horizontal run.
+    const endYRatio = drag.kind === "ray" ? drag.startYRatio : drag.endYRatio;
+    const start = drawingPointFrom(scene, domain, drag.startXRatio, drag.startYRatio);
+    const end = drawingPointFrom(scene, domain, drag.endXRatio, endYRatio);
+    return start && end ? { id: shapedDrawingId(drag.kind, id), panelId: panel.id, points: [start, end], color } : null;
+  }
   const source = drag.kind === "pencil" && drag.path.length > 1
     ? drag.path
     : [
@@ -152,11 +180,74 @@ export function resolveDrawingFromDrag(
   return points.length < 2 ? null : { id, panelId: panel.id, points, color };
 }
 
+function isShapedTool(kind: ChartToolKind): kind is typeof SHAPED_TOOLS[number] {
+  return (SHAPED_TOOLS as readonly string[]).includes(kind);
+}
+
+/** The id a drawing of this tool is saved under, see `chartDrawingShape`. */
+export function shapedDrawingId(kind: ChartToolKind, id: string): string {
+  return isShapedTool(kind) ? `${kind}:${id}` : id;
+}
+
+type RatioPoint = { xRatio: number; yRatio: number };
+
+interface DrawingGeometry {
+  segments: Array<[RatioPoint, RatioPoint]>;
+  /** Corners of a filled box under the segments. */
+  box: [RatioPoint, RatioPoint] | null;
+  /** The points that can be grabbed and reshaped. */
+  anchors: RatioPoint[];
+  labels: Array<{ at: RatioPoint; text: string }>;
+}
+
+/** What a drawing paints, in plot ratios: shared by the bitmap, the vectors and the hit test. */
+function drawingGeometry(
+  scene: Pick<CompositeChartScene, "timeScale">,
+  panel: CompositePanelScene,
+  drawing: ChartDrawing,
+): DrawingGeometry | null {
+  const projected = projectDrawing(scene, panel, drawing);
+  if (!projected) return null;
+  const shape = chartDrawingShape(drawing);
+  if (shape === "line") {
+    return {
+      segments: projected.slice(1).map((point, index) => [projected[index]!, point]),
+      box: null,
+      anchors: projected.length === 2 ? projected : [],
+      labels: [],
+    };
+  }
+  const [start, end] = projected as [RatioPoint, RatioPoint];
+  if (shape === "ray") {
+    return { segments: [[start, { xRatio: 1, yRatio: start.yRatio }]], box: null, anchors: [start], labels: [] };
+  }
+  if (shape === "rect") {
+    const corner = (xRatio: number, yRatio: number) => ({ xRatio, yRatio });
+    const a = corner(start.xRatio, end.yRatio);
+    const b = corner(end.xRatio, start.yRatio);
+    return { segments: [[start, a], [a, end], [end, b], [b, start]], box: [start, end], anchors: [start, end], labels: [] };
+  }
+  const domain = resolveMeasureAxisDomain(panel)!;
+  const left = Math.min(start.xRatio, end.xRatio);
+  const right = Math.max(start.xRatio, end.xRatio);
+  const [from, to] = drawing.points as [ChartDrawingPoint, ChartDrawingPoint];
+  const segments: DrawingGeometry["segments"] = [];
+  const labels: DrawingGeometry["labels"] = [];
+  for (const level of FIB_LEVELS) {
+    const value = to.value + (from.value - to.value) * level;
+    const yRatio = projectCompositeValue(value, domain);
+    if (yRatio === null) continue;
+    segments.push([{ xRatio: left, yRatio }, { xRatio: right, yRatio }]);
+    labels.push({ at: { xRatio: left, yRatio }, text: `${level} ${formatCompositeCursorValue(value, domain)}` });
+  }
+  return { segments, box: null, anchors: [start, end], labels };
+}
+
 function projectDrawing(
   scene: Pick<CompositeChartScene, "timeScale">,
   panel: CompositePanelScene,
   drawing: ChartDrawing,
-): Array<{ xRatio: number; yRatio: number }> | null {
+): RatioPoint[] | null {
   const domain = resolveMeasureAxisDomain(panel);
   if (!domain) return null;
   const projected: Array<{ xRatio: number; yRatio: number }> = [];
@@ -198,22 +289,21 @@ export function hitTestDrawings(
   let best: { hit: ChartDrawingHit; distance: number; endpoint: boolean } | null = null;
   const scale = Math.max(aspect, Number.EPSILON);
   const target = { x: pointer.xRatio * scale, y: pointer.yRatio };
+  const toPlot = (point: RatioPoint) => ({ x: point.xRatio * scale, y: point.yRatio });
   for (const drawing of drawings) {
     if (drawing.panelId !== panel.id) continue;
-    const projected = projectDrawing(scene, panel, drawing);
-    if (!projected) continue;
-    const shape = projected.map((point) => ({ x: point.xRatio * scale, y: point.yRatio }));
-    if (drawing.points.length === 2) {
-      for (const [index, point] of shape.entries()) {
-        const distance = Math.hypot(target.x - point.x, target.y - point.y);
-        if (distance > DRAWING_GRAB_RATIO) continue;
-        if (!best?.endpoint || best.distance > distance) {
-          best = { hit: { drawing, pointIndex: index }, distance, endpoint: true };
-        }
+    const geometry = drawingGeometry(scene, panel, drawing);
+    if (!geometry) continue;
+    for (const [index, anchor] of geometry.anchors.entries()) {
+      const point = toPlot(anchor);
+      const distance = Math.hypot(target.x - point.x, target.y - point.y);
+      if (distance > DRAWING_GRAB_RATIO) continue;
+      if (!best?.endpoint || best.distance > distance) {
+        best = { hit: { drawing, pointIndex: index }, distance, endpoint: true };
       }
     }
-    for (let index = 1; index < shape.length; index += 1) {
-      const distance = distanceToSegment(target, shape[index - 1]!, shape[index]!);
+    for (const [from, to] of geometry.segments) {
+      const distance = distanceToSegment(target, toPlot(from), toPlot(to));
       if (distance > DRAWING_GRAB_RATIO || best?.endpoint) continue;
       if (!best || best.distance > distance) {
         best = { hit: { drawing, pointIndex: null }, distance, endpoint: false };
@@ -235,19 +325,18 @@ export function shiftDrawing(
   const domain = resolveMeasureAxisDomain(panel);
   const projected = projectDrawing(scene, panel, drawing);
   if (!domain || !projected) return drawing;
-  return {
-    ...drawing,
-    points: drawing.points.map((point, index) => {
-      if (pointIndex !== null && index !== pointIndex) return point;
-      const source = projected[index]!;
-      return drawingPointFrom(
-        scene,
-        domain,
-        clamp(source.xRatio + deltaXRatio, 0, 1),
-        clamp(source.yRatio + deltaYRatio, 0, 1),
-      ) ?? point;
-    }),
-  };
+  const points = drawing.points.map((point, index) => {
+    if (pointIndex !== null && index !== pointIndex) return point;
+    const source = projected[index]!;
+    return drawingPointFrom(
+      scene,
+      domain,
+      clamp(source.xRatio + deltaXRatio, 0, 1),
+      clamp(source.yRatio + deltaYRatio, 0, 1),
+    ) ?? point;
+  });
+  if (chartDrawingShape(drawing) === "ray") points[1] = { ...points[1]!, value: points[0]!.value };
+  return { ...drawing, points };
 }
 
 export function nextDrawingColor(color: string): string {
@@ -268,7 +357,7 @@ export function resolveChartToolKind(modifiers: {
 }
 
 export function isDrawingTool(tool: ChartToolKind | null): boolean {
-  return tool === "line" || tool === "pencil";
+  return tool === "line" || tool === "pencil" || (tool !== null && isShapedTool(tool));
 }
 
 function isMeaningfulToolDrag(drag: ChartToolDrag): boolean {
@@ -458,20 +547,29 @@ export function buildChartToolVectors(input: {
 }): ChartVectorShape[] {
   const shapes: ChartVectorShape[] = [];
   for (const drawing of input.drawings) {
-    const projected = projectDrawing(input.scene, input.panel, drawing);
-    if (!projected) continue;
     const selected = input.selectedId === drawing.id;
-    shapes.push({
-      id: drawing.id,
-      points: projected.map((point) => ({ x: point.xRatio, y: point.yRatio })),
-      color: drawing.color,
-      strokeWidth: selected ? 2.4 : 1.6,
-      handles: selected && drawing.points.length === 2,
-    });
+    if (chartDrawingShape(drawing) === "line") {
+      const projected = projectDrawing(input.scene, input.panel, drawing);
+      if (!projected) continue;
+      shapes.push({
+        id: drawing.id,
+        points: projected.map((point) => ({ x: point.xRatio, y: point.yRatio })),
+        color: drawing.color,
+        strokeWidth: selected ? 2.4 : 1.6,
+        handles: selected && drawing.points.length === 2,
+      });
+      continue;
+    }
+    shapes.push(...shapedDrawingVectors(input.scene, input.panel, drawing, selected));
   }
 
   const drag = input.drag;
   if (!drag) return shapes;
+  if (isShapedTool(drag.kind)) {
+    const preview = resolveDrawingFromDrag(input.scene, input.panel, drag, input.colors.draw, "tool:draw");
+    if (preview) shapes.push(...shapedDrawingVectors(input.scene, input.panel, preview, false));
+    return shapes;
+  }
   const start = { x: drag.startXRatio, y: drag.startYRatio };
   const end = { x: drag.endXRatio, y: drag.endYRatio };
   if (drag.kind === "zoom") {
@@ -505,6 +603,55 @@ export function buildChartToolVectors(input: {
   return shapes;
 }
 
+function shapedDrawingVectors(
+  scene: Pick<CompositeChartScene, "timeScale">,
+  panel: CompositePanelScene,
+  drawing: ChartDrawing,
+  selected: boolean,
+): ChartVectorShape[] {
+  const geometry = drawingGeometry(scene, panel, drawing);
+  if (!geometry) return [];
+  const toVector = (point: RatioPoint) => ({ x: point.xRatio, y: point.yRatio });
+  const shapes: ChartVectorShape[] = [];
+  if (geometry.box) {
+    shapes.push({ id: `${drawing.id}:box`, points: geometry.box.map(toVector), color: drawing.color, box: true, fillOpacity: 0.12, strokeWidth: 0 });
+  }
+  geometry.segments.forEach((segment, index) => shapes.push({
+    id: `${drawing.id}:${index}`,
+    points: segment.map(toVector),
+    color: drawing.color,
+    strokeWidth: selected ? 2 : 1.3,
+    ...(geometry.labels[index] ? { label: geometry.labels[index]!.text } : {}),
+  }));
+  if (selected) {
+    shapes.push({ id: `${drawing.id}:anchors`, points: geometry.anchors.map(toVector), color: drawing.color, opacity: 0, handles: true });
+  }
+  return shapes;
+}
+
+/** Paints a shaped drawing's segments, box and handles onto a raster. */
+function paintShapedDrawing(
+  data: Uint8Array,
+  width: number,
+  height: number,
+  geometry: DrawingGeometry,
+  color: RgbaColor,
+  selected: boolean,
+): void {
+  const maxX = Math.max(width - 1, 0);
+  const maxY = Math.max(height - 1, 0);
+  if (geometry.box) {
+    const [a, b] = geometry.box;
+    fillRect(data, width, height, Math.min(a.xRatio, b.xRatio) * maxX, Math.min(a.yRatio, b.yRatio) * maxY,
+      Math.max(a.xRatio, b.xRatio) * maxX, Math.max(a.yRatio, b.yRatio) * maxY, color, 0.12);
+  }
+  for (const [from, to] of geometry.segments) {
+    drawLine(data, width, height, from.xRatio * maxX, from.yRatio * maxY, to.xRatio * maxX, to.yRatio * maxY, color, selected ? 2.2 : 1.4);
+  }
+  if (!selected) return;
+  for (const anchor of geometry.anchors) drawCircle(data, width, height, anchor.xRatio * maxX, anchor.yRatio * maxY, 3.2, color);
+}
+
 /**
  * Paints drawings and the active tool on a copy of the panel raster. Copying
  * keeps the cached plot bitmap intact and keeps a single bitmap layer, which is
@@ -529,10 +676,15 @@ export function drawChartToolOverlay(
   const maxY = Math.max(height - 1, 0);
 
   for (const drawing of drawings?.items ?? []) {
-    const shape = projectDrawing(drawings!.scene, drawings!.panel, drawing);
-    if (!shape) continue;
     const selected = drawings!.selectedId === drawing.id;
     const color = parseHex(drawing.color);
+    if (chartDrawingShape(drawing) !== "line") {
+      const geometry = drawingGeometry(drawings!.scene, drawings!.panel, drawing);
+      if (geometry) paintShapedDrawing(data, width, height, geometry, color, selected);
+      continue;
+    }
+    const shape = projectDrawing(drawings!.scene, drawings!.panel, drawing);
+    if (!shape) continue;
     for (let index = 1; index < shape.length; index += 1) {
       drawLine(
         data,
@@ -560,6 +712,13 @@ export function drawChartToolOverlay(
   const left = Math.min(x0, x1);
   const right = Math.max(x0, x1);
 
+  if (isShapedTool(drag.kind)) {
+    const preview = drawings && resolveDrawingFromDrag(drawings.scene, drawings.panel, drag, colors.draw, "tool:draw");
+    const geometry = preview && drawingGeometry(drawings.scene, drawings.panel, preview);
+    if (geometry) paintShapedDrawing(data, width, height, geometry, parseHex(colors.draw), false);
+    return { width, height, pixels: data };
+  }
+
   if (drag.kind === "line" || drag.kind === "pencil") {
     const color = parseHex(colors.draw);
     const trail = drag.kind === "pencil" && drag.path.length > 1

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

@@ -26,6 +26,7 @@ import {
   resolveZoomTimeRange,
   isDrawingTool,
   nextDrawingColor,
+  shapedDrawingId,
   type ChartDrawing,
   type ChartDrawingPoint,
   type ChartToolDrag,
@@ -301,7 +302,7 @@ export function useCompositeChartKeyboard({
     const placement = keyboardPlacement;
     setKeyboardPlacement(null);
     // A placement that never left its anchor spans nothing, like a click.
-    if (!placement || placement.start.time === placement.end.time) return;
+    if (!placement || (placement.start.time === placement.end.time && placement.kind !== "ray")) return;
     if (placement.kind === "zoom") {
       if (!navigationFrame) return;
       const range = resolveZoomTimeRange(placement.start.time, placement.end.time, navigationFrame.minimumSpanMs);
@@ -313,9 +314,9 @@ export function useCompositeChartKeyboard({
       ? placement.path.filter((point, index, path) => (
         index === 0 || point.time !== path[index - 1]!.time || point.value !== path[index - 1]!.value
       ))
-      : [placement.start, placement.end];
+      : [placement.start, placement.kind === "ray" ? { ...placement.end, value: placement.start.value } : placement.end];
     if (points.length < 2) return;
-    addDrawing({ id: nextDrawingId(), panelId: placement.panelId, points, color: drawColor });
+    addDrawing({ id: shapedDrawingId(placement.kind, nextDrawingId()), panelId: placement.panelId, points, color: drawColor });
   };
   const stepLegend = (direction: -1 | 1) => {
     onActivate?.();
@@ -566,7 +567,10 @@ export function useCompositeChartKeyboard({
       || ((interaction === "arm-measure"
         || interaction === "arm-zoom"
         || interaction === "arm-line"
-        || interaction === "arm-pencil") && !scene)
+        || interaction === "arm-pencil"
+        || interaction === "arm-ray"
+        || interaction === "arm-rect"
+        || interaction === "arm-fib") && !scene)
       || (interaction === "arm-level" && !levelsEditable)
       || (interaction === "delete-drawing" && !canDeleteDrawing)
       || (interaction === "cycle-colour" && !isDrawingTool(armedTool) && !selectedDrawingId)
@@ -586,6 +590,9 @@ export function useCompositeChartKeyboard({
       case "arm-zoom":
       case "arm-line":
       case "arm-pencil":
+      case "arm-ray":
+      case "arm-rect":
+      case "arm-fib":
       case "arm-level":
         onActivate?.();
         armTool(ARMED_TOOL_BY_INTERACTION[interaction]);

package/src/components/command-bar/assist/inventory.ts

@@ -119,7 +119,8 @@ export function buildAssistCommandInventory({
       prefixes: normalizePrefixes(command.shortcut ? [command.shortcut] : []),
     })),
     ...paneTemplates.map((template) => ({
-      descriptor: describe(
+      // An unlisted function keeps its codes, so nothing else takes them, but is never suggested.
+      descriptor: template.listed === false ? null : describe(
         template.shortcut?.prefix ?? "",
         getPaneTemplateDisplayLabel(template),
         template.shortcut?.aliases?.length ? `${template.description} Also ${template.shortcut.aliases.join(", ")}.` : template.description,

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

@@ -245,19 +245,34 @@ export function runDirectCommandAction(options: {
     }
     case "import-config": {
       const importPath = getDefaultConfigBackupPath();
-      void importConfig(state.config.dataDir, importPath)
-        .then((imported) => {
-          cancelThemePreview();
-          clearTransientThemePreview();
-          dispatch({ type: "SET_CONFIG", config: imported });
-          applyTheme(imported.theme);
-          dispatch({ type: "SET_THEME", theme: imported.theme });
-          notify(`Imported config from ${importPath}.`, { type: "success" });
-          closeAll({ revertThemePreview: false });
-        })
-        .catch((error) => {
-          notify(error instanceof Error ? error.message : "Import failed.", { type: "error" });
-        });
+      // An import replaces every layout, portfolio and setting at once, so it
+      // is never one keystroke away.
+      openInlineConfirm({
+        confirmId: "import-config",
+        title: "Import Config",
+        body: [
+          `This replaces your layouts, portfolios, watchlists and settings with the ones saved in ${importPath}.`,
+          "What you have now is not kept unless you export it first.",
+        ],
+        confirmLabel: "Import",
+        cancelLabel: "Back",
+        tone: "danger",
+        // A stray Enter keeps what is there.
+        defaultAction: "cancel",
+        onConfirm: async () => {
+          try {
+            const imported = await importConfig(getState().config.dataDir, importPath);
+            cancelThemePreview();
+            clearTransientThemePreview();
+            dispatch({ type: "SET_CONFIG", config: imported });
+            applyTheme(imported.theme);
+            dispatch({ type: "SET_THEME", theme: imported.theme });
+            notify(`Imported config from ${importPath}.`, { type: "success" });
+          } catch (error) {
+            notify(error instanceof Error ? error.message : "Import failed.", { type: "error" });
+          }
+        },
+      });
       return;
     }
     case "cycle-chart-renderer": {

package/src/components/command-bar/pane-templates/items.ts

@@ -260,8 +260,9 @@ export function buildPaneShortcutItems(options: {
     showShortcut?: boolean;
   }) => ResultItem;
 }): ResultItem[] {
+  // An unlisted template (`listed: false`) still opens when its code is typed, which is resolved apart from these rows.
   const items = options.templates
-    .filter((template) => template.shortcut && template.shortcut.showInBrowse !== false)
+    .filter((template) => template.shortcut && template.shortcut.showInBrowse !== false && template.listed !== false)
     .map((template) => options.createItem(template, {
       category: "Panes",
       createOptions: options.createOptions,
@@ -279,7 +280,7 @@ export function buildNonShortcutPaneTemplateItems(options: {
   createItem: (template: PaneTemplateDef, options?: { category?: string }) => ResultItem;
 }): ResultItem[] {
   const items = options.templates
-    .filter((template) => !template.shortcut)
+    .filter((template) => !template.shortcut && template.listed !== false)
     .map((template) => options.createItem(template, { category: "Panes" }));
 
   return options.filterQuery

package/src/components/command-bar/workflow/collection-actions.ts

@@ -36,7 +36,7 @@ import { resolvePortfolioTotalsCurrency } from "../../../portfolio/totals-curren
 import { createBaseConverter } from "../../../cli/base-converter";
 import { heldCurrencyUnit } from "../../../utils/currency-units";
 import { positionCostTermsPrefill } from "./portfolio-position";
-import { wholeUnitQuantityProblem } from "../../../portfolio/position-quantity";
+import { ambiguousQuantityProblem } from "../../../portfolio/position-quantity";
 import type { CommandBarFieldValue } from "./types";
 import type { WorkflowStringValues } from "./broker";
 import { coerceFieldString } from "../helpers";
@@ -259,8 +259,8 @@ export function createCommandBarCollectionWorkflowActions(options: {
       // Negative for a short; zero is no position. A future counts contracts, and the messages say so.
       const quantityLabel = positionQuantityLabel(ticker);
       const shares = readTypedNumber(coerceFieldString(values.shares), quantityLabel);
-      // 1.250 on a listing held in whole lots could be 1,250 as well, and asks the same way.
-      const lots = wholeUnitQuantityProblem(coerceFieldString(values.shares).trim(), ticker, { label: quantityLabel });
+      // 1.250 could be 1,250 as well, and asks the same way.
+      const lots = ambiguousQuantityProblem(coerceFieldString(values.shares).trim(), ticker, { label: quantityLabel });
       if (lots) throw new Error(lots);
       const sharesError = validatePositionShares(shares, quantityLabel);
       if (sharesError) {

package/src/components/onboarding/onboarding-wizard.tsx

@@ -421,7 +421,10 @@ export function OnboardingWizard(props: OnboardingWizardProps) {
             {persistenceError}
           </Text>
         ) : null}
-        <OnboardingActions hint={portfolioSub === "positions" && desktop ? tf("Later: {shortcut}, then AP.", { shortcut: commandBarShortcut }) : undefined}>
+        <OnboardingActions hint={portfolioSub === "positions" && desktop
+          // The step needs one ticker; once it has one, more can be added later.
+          ? positionCount === 0 ? t("Add one ticker to continue.") : tf("Later: {shortcut}, then AP.", { shortcut: commandBarShortcut })
+          : undefined}>
           {portfolioSub === "positions" ? (
             <>
               {brokerOptions.length > 0 && positionCount > 0 ? (

package/src/components/onboarding/portfolio-step/positions-panel.tsx

@@ -279,6 +279,17 @@ function TuiFieldRow({
   );
 }
 
+/**
+ * The line under the form: what Enter does, and how the step goes on. It
+ * needs one ticker, and while a field has the keyboard Enter adds, so Esc
+ * comes first.
+ */
+function positionsHint(editing: boolean, count: number): string {
+  if (!editing && count > 0) return tf("Enter continues · a adds another{broker}", { broker: "" });
+  const enter = editing ? t("Enter: next field, then add") : t("Enter to add a ticker");
+  return `${enter} · ${count > 0 ? t("Esc, then Enter: continue") : t("Add one ticker to continue")}`;
+}
+
 /** The size held: negative for a short. */
 function SignedNumberField(props: ComponentProps<typeof NumberField>) {
   return <NumberField {...props} allowNegative />;
@@ -302,13 +313,7 @@ function TuiPositionsPanel({ state, inputRef, editing, selectedSymbol, shortcut
         ) : state.submitting ? (
           <Text fg={colors.textDim}>{t("adding...")}</Text>
         ) : (
-          <Text fg={colors.textMuted}>
-            {editing
-              ? t("Enter: next field, then add.")
-              : state.positions.length > 0
-                ? tf("Enter continues · a adds another{broker}", { broker: "" })
-                : t("Enter to add a ticker.")}
-          </Text>
+          <Text fg={colors.textMuted}>{positionsHint(editing, state.positions.length)}</Text>
         )}
       </Box>
       <Box height={1} />

package/src/components/onboarding/wizard-broker-sync.ts

@@ -160,7 +160,6 @@ export function useOnboardingBrokerSync({
     draftConfig?: AppConfig,
   ) => importBrokerPositions(instanceId, undefined, {
     config: draftConfig,
-    persistResolvedBrokerConfig: true,
     signal,
     onCommitStart: () => {
       if (brokerSyncAttemptRef.current !== attemptId) return;

package/src/components/onboarding/wizard-positions.ts

@@ -12,7 +12,7 @@ import {
 } from "../../portfolio/mutations";
 import { isFuturesTicker } from "../../portfolio/futures-positions";
 import { loadFuturesEntrySize } from "../../portfolio/futures-terms";
-import { wholeUnitQuantityProblem } from "../../portfolio/position-quantity";
+import { ambiguousQuantityProblem } from "../../portfolio/position-quantity";
 import { useAppDispatch, useAppSelector, useAppStateRef } from "../../state/app/context";
 import { saveConfigImmediately } from "../../state/config-save-scheduler";
 import { resolveTickerSearch, upsertTickerFromSearchResult, type ResolvedTickerSearch } from "../../tickers/search";
@@ -292,8 +292,8 @@ export function useOnboardingPositions({
       if (shares === null) {
         nextTicker = addTickerToPortfolio(ticker, portfolioId).ticker;
       } else {
-        // 1.250 on a listing held in whole lots could be 1,250 as well, and asks as 1,250 does.
-        const lots = wholeUnitQuantityProblem(current.shares.trim(), ticker, { label: quantityLabel });
+        // 1.250 could be 1,250 as well, and asks as 1,250 does.
+        const lots = ambiguousQuantityProblem(current.shares.trim(), ticker, { label: quantityLabel });
         if (lots) {
           setFieldIdx(1);
           setError(lots);

package/src/components/ticker/list-table-view.tsx

@@ -34,6 +34,8 @@ import { PaneStatusBody } from "../ui/status";
 
 export interface TickerTableCell {
   text: string;
+  /** Muted context after `text`, shown whole only when both fit on one line. */
+  note?: string;
   color?: string;
   /** The full-precision number behind a rounded `text`, which exports and rendered-view reports keep. */
   value?: number | null;
@@ -293,11 +295,12 @@ export function TickerListTableView({
       };
     }
 
-    const { text, color, onPress, value, backgroundColor } = resolveCellRef.current.resolve(column, ticker, financials);
+    const { text, note, color, onPress, value, backgroundColor } = resolveCellRef.current.resolve(column, ticker, financials);
     const shouldFlash = flashSymbolsRef.current.has(ticker.metadata.ticker)
       && flashesOnQuoteTick(column.id, financials?.quote);
     return {
       text,
+      ...(note ? { note } : {}),
       ...(value !== undefined ? { value } : {}),
       color: color || (rowState.selected ? colors.selectedText : undefined),
       attributes: shouldFlash ? TextAttributes.DIM : TextAttributes.NONE,