gloomberb 0.17.6 → 0.18.0

package/src/renderers/electrobun/bun/core-capabilities.ts

@@ -209,7 +209,7 @@ function createNotesFilesCapability(): PluginCapability {
         await io(input).delete(file(input));
         return null;
       }, "action"),
-      listKeys: op((input: any) => io(input).listKeys()),
+      listKeys: op((input: any) => io(input).listKeys({ strict: input.strict === true })),
     },
   };
 }

package/src/renderers/electrobun/bun/desktop/backend.ts

@@ -470,7 +470,7 @@ export class DesktopBackend {
       case "desktop.dockDetachedPane":
       case "desktop.closeDetachedPane":
       case "desktop.focusDetachedPane":
-        return handleDesktopWorkspaceRequest(this, request);
+        return handleDesktopWorkspaceRequest(this, rpc, request);
       case "pluginState.setMany":
       case "pluginState.delete":
         return handleDesktopPluginStateRequest(this.requireServices().persistence.pluginState, request);

package/src/renderers/electrobun/bun/desktop/initialization.ts

@@ -108,6 +108,7 @@ export async function initializeDesktopBackend(
 ): Promise<ElectrobunBackendInit> {
   const windowTarget = normalizeInitWindowTarget(backend.rpcs.getRpcWindowKey(rpc), payload);
   backend.rpcs.markWindowRpcReady(rpc);
+  backend.stateBroadcaster.forgetWindowState(rpc);
 
   const currentConfig = backend.config;
   const currentServices = backend.services;

package/src/renderers/electrobun/bun/desktop/state-broadcaster.ts

@@ -17,9 +17,25 @@ interface DesktopStateBroadcasterOptions<Rpc extends DesktopStateRpc> {
   forEachReadyWindowRpc: (callback: (rpc: Rpc) => void) => void;
 }
 
+/**
+ * The parts of a snapshot a window applies, as the text the windows compare;
+ * the revision and layout flag only qualify them. Being text, it keeps no
+ * reference to objects this process may change later.
+ */
+function desktopStateKey(snapshot: DesktopSharedStateSnapshot): string {
+  return JSON.stringify({
+    config: snapshot.config,
+    paneState: snapshot.paneState,
+    focusedPaneId: snapshot.focusedPaneId,
+    statusBarVisible: snapshot.statusBarVisible,
+  });
+}
+
 export class DesktopStateBroadcaster<Rpc extends DesktopStateRpc> {
   private dockPreview: DesktopDockPreviewState = { paneId: null, edge: null };
   private themePreview: DesktopThemePreviewState = { theme: null };
+  /** The state held by each window that sends its whole state: what it last sent here or was sent. */
+  private readonly heldStateKeys = new WeakMap<Rpc, string>();
 
   constructor(private readonly options: DesktopStateBroadcasterOptions<Rpc>) {}
 
@@ -35,10 +51,36 @@ export class DesktopStateBroadcaster<Rpc extends DesktopStateRpc> {
     this.dockPreview = { paneId: null, edge: null };
   }
 
+  /** A window that sent its whole state holds it, and is not sent it back. */
+  noteWindowState(rpc: Rpc, snapshot: DesktopSharedStateSnapshot): void {
+    this.heldStateKeys.set(rpc, desktopStateKey(snapshot));
+  }
+
+  /** A window that starts over (a load or reload) gets every state until it sends its own. */
+  forgetWindowState(rpc: Rpc): void {
+    this.heldStateKeys.delete(rpc);
+  }
+
+  /**
+   * Sends the state to every ready window in the order the changes happen,
+   * except a window that sent its whole state and already holds this one: it
+   * would decode and compare the state only to drop it. A popped-out window
+   * gets every state. It applies one only when the part for its own pane
+   * changed, and then whole, so the state its own change produces is what
+   * brings its copy of the tabs and settings up to date.
+   */
   sendDesktopState(snapshot: DesktopSharedStateSnapshot | null): void {
     if (!snapshot) return;
-    const encodedSnapshot = encodeRpcValue(snapshot) as DesktopSharedStateSnapshot;
+    let encodedSnapshot: DesktopSharedStateSnapshot | null = null;
+    let snapshotKey: string | null = null;
     this.options.forEachReadyWindowRpc((rpc) => {
+      const heldKey = this.heldStateKeys.get(rpc);
+      if (heldKey !== undefined) {
+        snapshotKey ??= desktopStateKey(snapshot);
+        if (heldKey === snapshotKey) return;
+        this.heldStateKeys.set(rpc, snapshotKey);
+      }
+      encodedSnapshot ??= encodeRpcValue(snapshot) as DesktopSharedStateSnapshot;
       rpc.send["desktop.state"]({
         snapshot: encodedSnapshot,
       });

package/src/renderers/electrobun/bun/desktop/workspace/requests.ts

@@ -1,5 +1,5 @@
 import type { DesktopWorkspaceRequest } from "../../../shared/protocol";
-import type { DesktopBackend } from "../backend";
+import type { DesktopBackend, DesktopRpc } from "../backend";
 
 type DockEdge = "left" | "right" | "top" | "bottom";
 
@@ -18,6 +18,7 @@ function normalizeDockEdge(edge: unknown): DockEdge | undefined {
 
 export async function handleDesktopWorkspaceRequest(
   backend: DesktopBackend,
+  rpc: DesktopRpc,
   request: DesktopWorkspaceRequest,
 ): Promise<null> {
   const workspace = backend.requireWorkspace();
@@ -27,6 +28,9 @@ export async function handleDesktopWorkspaceRequest(
       const snapshot = workspace.syncMainState(request.payload.snapshot);
       backend.setConfig(snapshot.config);
       detachedWindows.reconcile();
+      // The main window holds what it sent. It gets the state back only when
+      // this process changed it: a popped-out window's frame, a stale revision.
+      stateBroadcaster.noteWindowState(rpc, request.payload.snapshot);
       stateBroadcaster.sendDesktopState(snapshot);
       return null;
     }

package/src/renderers/electrobun/shared/rpc-codec.ts

@@ -1,5 +1,6 @@
 import { ApiRequestError } from "../../../api-client/errors";
 import { isHistoryRetentionError, parseHistoryRetentionError } from "../../../sources/history-retention";
+import { isProviderBusy, ProviderBusyError } from "../../../sources/provider-errors";
 
 const DATE_MARKER = "__gloomDate";
 const MAP_MARKER = "__gloomMap";
@@ -15,6 +16,8 @@ export async function encodeRpcResponse(load: () => unknown | Promise<unknown>):
       ok: false,
       error: { kind: "history-retention", retention: error.retention, candidates: error.candidates, outcomes: error.outcomes },
     };
+    // A search the view runs must tell a busy source from one that found nothing.
+    if (isProviderBusy(error)) return { [RESPONSE_MARKER]: 1, ok: false, error: { kind: "provider-busy", message: error.message } };
     if (!(error instanceof ApiRequestError)) throw error;
     return {
       [RESPONSE_MARKER]: 1,
@@ -36,6 +39,10 @@ export function decodeRpcResponse<T = unknown>(value: unknown): T {
     if (!retention) throw new Error("Invalid desktop response");
     throw retention;
   }
+  if (response.ok === false && error && typeof error === "object" && error.kind === "provider-busy") {
+    if (typeof error.message !== "string") throw new Error("Invalid desktop response");
+    throw new ProviderBusyError(error.message);
+  }
   if (response.ok !== false || !error || typeof error !== "object"
     || (error.kind !== undefined && error.kind !== "api")
     || typeof error.message !== "string"

package/src/renderers/electrobun/view/cli-pane-shot-entry.tsx

@@ -3,6 +3,7 @@ import { createRoot } from "react-dom/client";
 import { useEffect, useState, type ReactNode } from "react";
 import { TapeClientContext } from "../../../plugins/builtin/time-sales/use-tape";
 import { createSnapshotTapeClient } from "../../../plugins/builtin/time-sales/snapshot-client";
+import { createSnapshotScannerClient, ScannerClientContext } from "../../../plugins/builtin/shared/scanner-capture";
 import type { TapeSnapshot } from "../../../api-client/tape";
 import { AppProvider, useAppDispatch } from "../../../state/app/context";
 import { createCliPaneShotConnectionHealth } from "./cli-pane-shot-health";
@@ -513,25 +514,28 @@ async function render() {
 
   const tapeClient = createSnapshotTapeClient(payload.tapeSnapshots ?? [],
     (symbol, exchange) => requestShotMarketData<TapeSnapshot>("getCloudTape", [symbol, exchange]));
+  const scannerClient = createSnapshotScannerClient(payload.scannerSnapshots ?? []);
   createRoot(rootElement).render(
     <TapeClientContext.Provider value={tapeClient}>
-      <RemoteUiRegistryProvider>
-        <CaptureShotSemanticUi />
-        <DomHostProviders ui={webUiHost} renderer={rendererHost}>
-          <AppProvider config={payload.config} desktopSnapshot={{
-            config: payload.config,
-            paneState: payload.paneState,
-            focusedPaneId: payload.paneId,
-            statusBarVisible: false,
-          }}>
-            <HydratePayload payload={payload}>
-              <ChartSnapshotContext.Provider value={payload.chartModel ?? null}>
-                <ShotPane payload={payload} registry={services.pluginRegistry} />
-              </ChartSnapshotContext.Provider>
-            </HydratePayload>
-          </AppProvider>
-        </DomHostProviders>
-      </RemoteUiRegistryProvider>
+      <ScannerClientContext.Provider value={scannerClient}>
+        <RemoteUiRegistryProvider>
+          <CaptureShotSemanticUi />
+          <DomHostProviders ui={webUiHost} renderer={rendererHost}>
+            <AppProvider config={payload.config} desktopSnapshot={{
+              config: payload.config,
+              paneState: payload.paneState,
+              focusedPaneId: payload.paneId,
+              statusBarVisible: false,
+            }}>
+              <HydratePayload payload={payload}>
+                <ChartSnapshotContext.Provider value={payload.chartModel ?? null}>
+                  <ShotPane payload={payload} registry={services.pluginRegistry} />
+                </ChartSnapshotContext.Provider>
+              </HydratePayload>
+            </AppProvider>
+          </DomHostProviders>
+        </RemoteUiRegistryProvider>
+      </ScannerClientContext.Provider>
     </TapeClientContext.Provider>,
   );
 }

package/src/renderers/electrobun/view/cli-pane-shot-frame.tsx

@@ -2,7 +2,7 @@
 import { useCallback, useEffect, useRef, useState, type ReactNode } from "react";
 import { FloatingPaneWrapper } from "../../../components/layout/floating-pane";
 import { CaptureDatesDataContext } from "../../../components/layout/pane/capture-status";
-import { PaneFooterProvider, hasPaneFooterContent, type PaneFooterSegment } from "../../../components/layout/pane/footer";
+import { PaneFooterProvider, datesPaneData, hasPaneFooterContent, type PaneFooterSegment } from "../../../components/layout/pane/footer";
 import { resolvePaneBodyFrame } from "../../../components/layout/pane/sizing";
 
 /** What a capture's status line dates (`CaptureStatusLine`): the pane's own data, the quotes on screen, or neither. */
@@ -150,9 +150,9 @@ export function PaneShotFrame({ paneId, title, width, height, preserveStatus = f
   return <PaneFooterProvider>{(registeredFooter) => {
     const status: PaneFooterSegment[] = statusLine ? [{ id: "shot-status", parts: [{ text: statusText, tone: "label" }] }] : [];
     const info = registeredFooter.info.filter((segment) => (preserveStatus || segment.icon === "warning")
-      && !(segment.asOf && (datesData || crowded))
+      && !(datesPaneData(segment) && (datesData || crowded))
       && !(segment.quoteStatus && statusLine && dates !== null));
-    shownAsOf.current = info.some((segment) => segment.asOf);
+    shownAsOf.current = info.some(datesPaneData);
     const footer = { info: [...info, ...status], hints: [], menu: [], keys: [] };
     const bodyFrame = resolvePaneBodyFrame({
       width,

package/src/renderers/electrobun/view/desktop/window/bridge.ts

@@ -6,12 +6,12 @@ import type {
   DesktopWindowBridge,
 } from "../../../../../types/desktop-window";
 import { backendRequest, getElectrobunBackendInitSnapshot, onBackendMessage } from "../../backend-rpc";
-import { detachedSnapshotKey, prepareDetachedSnapshot } from "./snapshot";
+import { createDetachedSnapshotFilter } from "./snapshot";
 
 export function createDesktopWindowBridge(kind: "main" | "detached", paneId?: string): DesktopWindowBridge {
   const initialDesktopSnapshot = getElectrobunBackendInitSnapshot()?.desktopSnapshot ?? null;
-  let lastDetachedSnapshotKey = kind === "detached" && paneId && initialDesktopSnapshot
-    ? detachedSnapshotKey(initialDesktopSnapshot, paneId)
+  const takeDetachedSnapshot = kind === "detached" && paneId
+    ? createDetachedSnapshotFilter(paneId, initialDesktopSnapshot)
     : null;
 
   return {
@@ -46,11 +46,9 @@ export function createDesktopWindowBridge(kind: "main" | "detached", paneId?: st
     },
     subscribeState(listener: (snapshot: DesktopSharedStateSnapshot) => void) {
       return onBackendMessage("desktop.state", (message) => {
-        if (kind === "detached" && paneId) {
-          const nextKey = detachedSnapshotKey(message.snapshot, paneId);
-          if (nextKey === lastDetachedSnapshotKey) return;
-          lastDetachedSnapshotKey = nextKey;
-          listener(prepareDetachedSnapshot(message.snapshot, paneId));
+        if (takeDetachedSnapshot) {
+          const snapshot = takeDetachedSnapshot(message.snapshot);
+          if (snapshot) listener(snapshot);
           return;
         }
         listener(message.snapshot);

package/src/renderers/electrobun/view/desktop/window/snapshot.ts

@@ -39,3 +39,21 @@ export function detachedSnapshotKey(snapshot: DesktopSharedStateSnapshot, paneId
     paneState: Object.fromEntries(paneStateIds.map((id) => [id, snapshot.paneState[id] ?? {}])),
   });
 }
+
+/**
+ * What a popped-out window takes of each state it is sent: nothing unless the
+ * part for its pane and the panes it follows changed, and then all of it,
+ * config included.
+ */
+export function createDetachedSnapshotFilter(
+  paneId: string,
+  initialSnapshot: DesktopSharedStateSnapshot | null,
+): (snapshot: DesktopSharedStateSnapshot) => DesktopSharedStateSnapshot | null {
+  let lastKey = initialSnapshot ? detachedSnapshotKey(initialSnapshot, paneId) : null;
+  return (snapshot) => {
+    const nextKey = detachedSnapshotKey(snapshot, paneId);
+    if (nextKey === lastKey) return null;
+    lastKey = nextKey;
+    return prepareDetachedSnapshot(snapshot, paneId);
+  };
+}

package/src/series/capability.ts

@@ -21,6 +21,7 @@ export async function resolveRegisteredSeries(
   const resolved = await resolveLoadedSeries(found.series.definition as LoadedSeriesDefinition, {
     viewport,
     ...(found.ticker ? { ticker: found.ticker } : {}),
+    ...(found.line ? { line: found.line } : {}),
     ...(signal ? { signal } : {}),
   });
   // The same checks a series from another process passes.

package/src/series/files.ts

@@ -1,3 +1,4 @@
+import { logFailure } from "../utils/log-failure";
 import { inferSeriesFrequency, parseSeriesCsv } from "./csv";
 import type { SeriesDefinition, SeriesFrequency } from "./types";
 import { SERIES_FREQUENCIES, isValidSeriesUnit } from "./validate";
@@ -78,7 +79,9 @@ export async function listSeriesFiles(dataDir: string): Promise<SeriesFolderFile
   let names: string[];
   try {
     names = (await readdir(folder)).filter((name) => name.toLowerCase().endsWith(".csv"));
-  } catch {
+  } catch (error) {
+    // An absent optional file or directory is expected.
+    if ((error as { code?: unknown } | null)?.code !== "ENOENT") logFailure("series.files", "Listing series files failed")(error);
     return [];
   }
   const files = await Promise.all(names.map(async (name): Promise<SeriesFolderFile | null> => {
@@ -86,7 +89,9 @@ export async function listSeriesFiles(dataDir: string): Promise<SeriesFolderFile
     try {
       const { mtimeMs } = await stat(path);
       return { name, mtimeMs, readText: () => readFile(path, "utf-8") };
-    } catch {
+    } catch (error) {
+      // An absent optional file or directory is expected.
+      if ((error as { code?: unknown } | null)?.code !== "ENOENT") logFailure("series.files", "Reading series file metadata failed")(error);
       return null;
     }
   }));
@@ -99,7 +104,8 @@ export async function readSeriesFolder(dataDir: string): Promise<SeriesDefinitio
   const definitions = await Promise.all(files.map(async (file) => {
     try {
       return seriesFromFile(file.name, await file.readText(), file.readText);
-    } catch {
+    } catch (error) {
+      logFailure("series.files", "Reading series definitions failed")(error);
       return [];
     }
   }));

package/src/series/registry.ts

@@ -8,11 +8,15 @@ import type {
   RegisteredSeries,
   SeriesCatalogEntry,
   SeriesDefinition,
+  SeriesLine,
 } from "./types";
 
+/** Between a series' name and one of its lines in a capability series id: `bands~upper/AAPL`. */
+const LINE_SEPARATOR = "~";
+
 /** The expression a loaded series charts as: the namespace is its chart-series capability. */
-function loadedSeriesExpression(definition: Pick<SeriesDefinition, "id" | "input">): string {
-  return `CAP:${definition.id}${definition.input ? `/${TICKER_PLACEHOLDER}` : ""}`;
+function loadedSeriesExpression(definition: Pick<SeriesDefinition, "id" | "input">, lineId?: string): string {
+  return `CAP:${definition.id}${lineId ? `${LINE_SEPARATOR}${lineId}` : ""}${definition.input ? `/${TICKER_PLACEHOLDER}` : ""}`;
 }
 
 export function seriesExpression(definition: SeriesDefinition): string {
@@ -20,25 +24,31 @@ export function seriesExpression(definition: SeriesDefinition): string {
 }
 
 /**
- * The capability series id a loaded series charts under: its name, and for a
- * series with an input, the symbol after a slash (`days-to-cover/AAPL`).
+ * The capability series id a loaded series charts under: its name, one of its
+ * lines after a tilde, and for a series with an input, the symbol after a
+ * slash (`days-to-cover/AAPL`, `bands~upper/AAPL`).
  */
-export function capabilitySeriesId(definition: Pick<SeriesDefinition, "id">, ticker?: string): string {
-  const name = splitSeriesId(definition.id)?.name ?? definition.id;
+export function capabilitySeriesId(definition: Pick<SeriesDefinition, "id">, ticker?: string, lineId?: string): string {
+  const name = `${splitSeriesId(definition.id)?.name ?? definition.id}${lineId ? `${LINE_SEPARATOR}${lineId}` : ""}`;
   return ticker ? `${name}/${encodeURIComponent(ticker.trim().toUpperCase())}` : name;
 }
 
-/** The registered id and the typed symbol a capability series id names. */
-function parseCapabilitySeriesId(namespace: string, seriesId: string): { id: string; ticker?: string } {
+/** The registered id, the line and the typed symbol a capability series id names. */
+function parseCapabilitySeriesId(namespace: string, seriesId: string): { id: string; ticker?: string; line?: string } {
   const slash = seriesId.indexOf("/");
-  if (slash < 0) return { id: `${namespace}:${seriesId}` };
+  const named = slash < 0 ? seriesId : seriesId.slice(0, slash);
+  const tilde = named.indexOf(LINE_SEPARATOR);
+  const name = tilde < 0 ? named : named.slice(0, tilde);
+  const line = tilde < 0 ? undefined : named.slice(tilde + 1);
+  const base = { id: `${namespace}:${name}`, ...(line ? { line } : {}) };
+  if (slash < 0) return base;
   let ticker: string;
   try {
     ticker = decodeURIComponent(seriesId.slice(slash + 1));
   } catch {
     ticker = seriesId.slice(slash + 1);
   }
-  return { id: `${namespace}:${seriesId.slice(0, slash)}`, ticker };
+  return { ...base, ticker };
 }
 
 export function seriesCatalogEntry(series: RegisteredSeries): SeriesCatalogEntry {
@@ -54,6 +64,16 @@ export function seriesCatalogEntry(series: RegisteredSeries): SeriesCatalogEntry
     ...(definition.publisher ? { publisher: definition.publisher } : {}),
     ...(definition.url ? { url: definition.url } : {}),
     ...(definition.input ? { input: definition.input } : {}),
+    ...(definition.placement ? { placement: definition.placement } : {}),
+    ...(definition.lines?.length ? {
+      lines: definition.lines.map((line) => ({
+        id: line.id,
+        name: line.name,
+        // A line shading the area to another is drawn as a band: its line inside the shade.
+        ...(line.fill ? { style: "band" as const } : line.style ? { style: line.style } : {}),
+        expression: loadedSeriesExpression(definition, line.id),
+      })),
+    } : {}),
     expression: seriesExpression(definition),
     pluginId,
   };
@@ -131,14 +151,20 @@ export class SeriesRegistry {
     return this.namespaces.get(namespace)?.pluginId;
   }
 
-  /** The loaded series a chart-series capability source names, with the typed symbol. */
-  findLoaded(capabilityId: string, seriesId: string): { series: RegisteredSeries; ticker?: string } | null {
+  /**
+   * The loaded series a chart-series capability source names, with the typed
+   * symbol and the line. A series with lines named without one is its first line.
+   */
+  findLoaded(capabilityId: string, seriesId: string): { series: RegisteredSeries; ticker?: string; line?: SeriesLine } | null {
     if (!this.namespaces.has(capabilityId)) return null;
-    const { id, ticker } = parseCapabilitySeriesId(capabilityId, seriesId);
+    const { id, ticker, line: lineId } = parseCapabilitySeriesId(capabilityId, seriesId);
     const series = this.entries.get(id);
     if (!series?.definition.load) return null;
     if (!!series.definition.input !== !!ticker) return null;
-    return { series, ...(ticker ? { ticker } : {}) };
+    const lines = series.definition.lines;
+    const line = lines?.length ? lineId ? lines.find((entry) => entry.id === lineId) : lines[0] : undefined;
+    if (lineId && !line) return null;
+    return { series, ...(ticker ? { ticker } : {}), ...(line ? { line } : {}) };
   }
 
   /** The series that charts as this exact expression (`FRED:UNRATE`), if one without an input does. */

package/src/series/resolve.ts

@@ -6,12 +6,16 @@ import type {
   SeriesPeriod,
   TimeSeriesPoint,
 } from "../time-series/types";
+import { getPresetResolution, type ManualChartResolution } from "../time-series/resolution";
 import { SERIES_COLORS } from "../theme/series-colors";
 import type {
   LoadedSeriesDefinition,
   SeriesFrequency,
+  SeriesLine,
+  SeriesLinesLoadResult,
   SeriesLoadOutput,
   SeriesLoadRequest,
+  SeriesLoadResult,
   SeriesPoint,
 } from "./types";
 
@@ -25,8 +29,7 @@ function seriesPointDate(value: SeriesPoint["date"]): Date | null {
   return Number.isFinite(date.getTime()) ? date : null;
 }
 
-/** Oldest first, one point per instant (the last one given wins), at most the chart's point limit. */
-export function normalizeSeriesPoints(points: readonly SeriesPoint[]): TimeSeriesPoint[] {
+function valuesByTime(points: readonly SeriesPoint[]): Map<number, number | null> {
   const byTime = new Map<number, number | null>();
   for (const point of points) {
     const date = point ? seriesPointDate(point.date) : null;
@@ -34,10 +37,24 @@ export function normalizeSeriesPoints(points: readonly SeriesPoint[]): TimeSerie
     const value = typeof point.value === "number" && Number.isFinite(point.value) ? point.value : null;
     byTime.set(date.getTime(), value);
   }
+  return byTime;
+}
+
+/**
+ * Oldest first, one point per instant (the last one given wins), at most the
+ * chart's point limit. With `edge`, another line's points, each point spans
+ * from its value to that line's value at the same instant: a band's range.
+ */
+export function normalizeSeriesPoints(points: readonly SeriesPoint[], edge?: readonly SeriesPoint[]): TimeSeriesPoint[] {
+  const byTime = valuesByTime(points);
+  const edges = edge ? valuesByTime(edge) : null;
   const sorted = [...byTime].sort(([left], [right]) => left - right);
   return sorted.slice(-MAX_CHART_SERIES_POINTS).map(([time, value]) => {
     const date = new Date(time);
-    return { date, observedAt: date, value };
+    const other = edges?.get(time);
+    return value !== null && other != null
+      ? { date, observedAt: date, value, low: Math.min(value, other), high: Math.max(value, other) }
+      : { date, observedAt: date, value };
   });
 }
 
@@ -50,11 +67,16 @@ function seriesUnitGroup(unit: string): string {
   return unit === "%" ? "percent" : `series:${unit.toLowerCase()}`;
 }
 
-/** One colour per id, so two loaded series on a chart are told apart. */
-function seriesColor(id: string): string {
+/** One colour per id, so two loaded series on a chart are told apart; a series' lines take the colours after it. */
+function seriesColor(id: string, lineIndex = 0): string {
   let hash = 0;
   for (const char of id) hash = (hash * 31 + char.charCodeAt(0)) >>> 0;
-  return SERIES_COLORS[hash % SERIES_COLORS.length]!;
+  return SERIES_COLORS[(hash + lineIndex) % SERIES_COLORS.length]!;
+}
+
+/** The bar size a chart draws prices in: the one it was set to, else its range's default. */
+function viewportResolution(viewport: ChartViewportSpec): ManualChartResolution {
+  return viewport.resolution === "auto" ? getPresetResolution(viewport.range) : viewport.resolution;
 }
 
 /** The dates a chart viewport covers, as a series load request takes them. */
@@ -68,32 +90,113 @@ export function seriesLoadWindow(viewport: ChartViewportSpec, now = new Date()):
   return { start: subtractTimeRange(now, viewport.range) };
 }
 
-function loadResult(output: SeriesLoadOutput): Exclude<SeriesLoadOutput, readonly SeriesPoint[]> {
-  if (Array.isArray(output)) return { points: output };
-  const result = output as Exclude<SeriesLoadOutput, readonly SeriesPoint[]>;
+function loadResult(output: SeriesLoadOutput, line: SeriesLine | undefined): SeriesLoadResult & { edge?: readonly SeriesPoint[] } {
+  if (Array.isArray(output)) {
+    if (line) throw new Error("Series loader returned points where its lines were expected.");
+    return { points: output };
+  }
+  const result = output as Partial<SeriesLoadResult & SeriesLinesLoadResult> | null;
+  if (line) {
+    if (!result || !result.lines || typeof result.lines !== "object") throw new Error("Series loader returned no lines.");
+    const { lines, ...rest } = result;
+    const points = lines[line.id];
+    const edge = line.fill ? lines[line.fill] : undefined;
+    // A line the loaded data no longer has (the series changed under a saved chart) draws nothing.
+    return { ...rest, points: Array.isArray(points) ? points : [], ...(Array.isArray(edge) ? { edge } : {}) };
+  }
   if (!result || !Array.isArray(result.points)) throw new Error("Series loader returned no points.");
-  return result;
+  return result as SeriesLoadResult;
+}
+
+/** How long one load is shared by the lines of a series that ask for it together. */
+const SHARED_LOAD_MS = 2_000;
+
+interface SharedLoad {
+  output: Promise<SeriesLoadOutput>;
+  controller: AbortController;
+  /** Requests still waiting that can be called off. */
+  waiting: number;
+  /** A request that cannot be called off shares the load, so it runs to the end. */
+  kept: boolean;
+}
+
+const sharedLoads = new WeakMap<LoadedSeriesDefinition, Map<string, SharedLoad>>();
+
+/**
+ * Loads a series once for all of its lines: a chart asks for each line on its
+ * own, at the same time and for the same dates, and the loader runs once. The
+ * loader's signal aborts when every request sharing the load has.
+ */
+function loadSeries(definition: LoadedSeriesDefinition, request: SeriesLoadRequest): Promise<SeriesLoadOutput> {
+  if (!definition.lines?.length) return Promise.resolve(definition.load(request));
+  const { signal, ...shared } = request;
+  if (signal?.aborted) return Promise.reject(signal.reason);
+  // A window measured back from now moves by milliseconds between the lines' requests.
+  const minute = (date: Date | undefined) => date ? Math.floor(date.getTime() / 60_000) : null;
+  const key = JSON.stringify([shared.ticker ?? null, minute(shared.start), minute(shared.end), shared.resolution ?? null]);
+  let byKey = sharedLoads.get(definition);
+  if (!byKey) sharedLoads.set(definition, byKey = new Map());
+  let load = byKey.get(key);
+  if (!load) {
+    const controller = new AbortController();
+    const output = Promise.resolve().then(() => {
+      controller.signal.throwIfAborted();
+      return definition.load({ ...shared, signal: controller.signal });
+    });
+    const entry: SharedLoad = { output, controller, waiting: 0, kept: false };
+    load = entry;
+    byKey.set(key, entry);
+    const forget = () => {
+      const timer = setTimeout(() => { if (byKey.get(key) === entry) byKey.delete(key); }, SHARED_LOAD_MS);
+      (timer as { unref?: () => void }).unref?.();
+    };
+    output.then(forget, forget);
+  }
+  const entry = load;
+  if (!signal) {
+    entry.kept = true;
+    return entry.output;
+  }
+  entry.waiting += 1;
+  return new Promise<SeriesLoadOutput>((resolve, reject) => {
+    const onAbort = () => {
+      entry.waiting -= 1;
+      if (entry.waiting === 0 && !entry.kept) {
+        if (byKey.get(key) === entry) byKey.delete(key);
+        entry.controller.abort(signal.reason);
+      }
+      reject(signal.reason);
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    entry.output.then(resolve, reject).finally(() => signal.removeEventListener("abort", onAbort));
+  });
 }
 
 export async function resolveLoadedSeries(
   definition: LoadedSeriesDefinition,
-  request: { viewport: ChartViewportSpec; ticker?: string; signal?: AbortSignal },
+  request: { viewport: ChartViewportSpec; ticker?: string; line?: SeriesLine; signal?: AbortSignal },
   now = new Date(),
 ): Promise<ResolvedSeries> {
   const ticker = request.ticker?.trim().toUpperCase() || undefined;
-  const { points, warning, attribution } = loadResult(await definition.load({
+  const line = definition.lines?.length ? request.line ?? definition.lines[0] : undefined;
+  const { points, edge, warning, attribution } = loadResult(await loadSeries(definition, {
     ...seriesLoadWindow(request.viewport, now),
     ...(ticker ? { ticker } : {}),
+    resolution: viewportResolution(request.viewport),
     ...(request.signal ? { signal: request.signal } : {}),
-  }));
-  const id = ticker ? `${definition.id}/${ticker}` : definition.id;
-  const style = definition.style ?? "line";
+  }), line);
+  const seriesId = ticker ? `${definition.id}/${ticker}` : definition.id;
+  const id = line ? `${definition.id}~${line.id}${ticker ? `/${ticker}` : ""}` : seriesId;
+  const name = line ? `${definition.name} · ${line.name}` : definition.name;
+  const style = line?.style ?? definition.style ?? "line";
   return {
     id,
-    label: ticker ? `${ticker} · ${definition.name}` : definition.name,
-    color: seriesColor(id),
+    label: ticker ? `${ticker} · ${name}` : name,
+    color: line?.color ?? definition.color ?? seriesColor(seriesId, line ? definition.lines!.indexOf(line) : 0),
     unit: definition.unit,
     unitGroup: seriesUnitGroup(definition.unit),
+    // Drawn in the ticker's price: the chart puts it on that price's axis.
+    ...(definition.placement === "price" && ticker ? { priceOf: ticker } : {}),
     nativeFrequency: nativeFrequency(definition.frequency),
     dataShape: "scalar",
     style,
@@ -103,6 +206,6 @@ export async function resolveLoadedSeries(
     interpolation: style === "step" ? "step-after" : "none",
     ...(warning ? { warning } : {}),
     ...(attribution ? { attribution: { ...attribution } } : {}),
-    points: normalizeSeriesPoints(points),
+    points: normalizeSeriesPoints(points, edge),
   };
 }

package/src/series/standalone.ts

@@ -1,3 +1,4 @@
+import { logFailure } from "../utils/log-failure";
 import { chartSeriesResolveRequestSchema } from "../capabilities/chart-series";
 import type { CapabilityInvoker } from "../capabilities/types";
 import type { GloomPlugin } from "../types/plugin";
@@ -23,8 +24,8 @@ export function standaloneSeriesInvoker(
       for (const definition of definitions) {
         try {
           built.register(pluginId, definition);
-        } catch {
-          // The app logs a definition it refuses; a report charts the rest.
+        } catch (error) {
+          logFailure("series.standalone", "Registering a standalone series failed")(error);
         }
       }
     };