gloomberb 0.12.0 → 0.13.2

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

@@ -2,7 +2,8 @@ import { existsSync, mkdirSync } from "fs";
 import { homedir } from "os";
 import { join } from "path";
 import { createAppServices, type AppServices } from "../../../../core/app-services";
-import { getDesktopBackendPlugins } from "../../../../plugins/catalog-backend";
+import { loadDesktopBackendPlugins } from "../../../../plugins/catalog-backend";
+import { restoreExtractedPlugins } from "../../../../cli/restore-plugins";
 import type { AppSessionSnapshot } from "../../../../core/state/session-persistence";
 import {
   getDataDir,
@@ -133,13 +134,19 @@ export async function initializeDesktopBackend<TRpc>(
     });
   }
 
-  options.setCurrentConfig(await initDataDir(await resolveDesktopDataDir()));
+  const initialConfig = await initDataDir(await resolveDesktopDataDir());
+  // Restore plugins that moved into their own repositories before the catalog
+  // is read, the same as the terminal does at startup. Without it a
+  // desktop-only user silently loses a feature the day it is extracted, since
+  // nothing else installs it for them.
+  const seededPlugins = await restoreExtractedPlugins();
+  options.setCurrentConfig(seededPlugins ? { ...initialConfig, seededPlugins } : initialConfig);
   const config = options.getCurrentConfig();
   if (!config) throw new Error("Desktop config failed to initialize.");
 
   const services = createAppServices({
     config,
-    plugins: getDesktopBackendPlugins(),
+    plugins: await loadDesktopBackendPlugins(),
   });
   options.setServices(services);
   await services.ready;

package/src/renderers/electrobun/bun/external-plugins.ts

@@ -1,11 +1,11 @@
-import { readdir, stat } from "fs/promises";
+import { readdir, rm, stat } from "fs/promises";
 import { existsSync } from "fs";
 import { join } from "path";
 
 import type { DesktopExternalPluginBundle } from "../shared/protocol";
 import { bundleExternalPlugin, pluginBundleCacheDir } from "../../../plugins/bundle";
 import { linkHostPackages } from "../../../plugins/host-link";
-import { getPluginsDir, resolvePluginEntry } from "../../../plugins/loader";
+import { getPluginCacheDir, getPluginsDir, isPluginDirectory, resolvePluginEntry } from "../../../plugins/loader";
 import type { GloomPlugin } from "../../../types/plugin";
 import { debugLog } from "../../../utils/debug-log";
 
@@ -60,15 +60,31 @@ async function readPluginMetadata(entryFile: string): Promise<GloomPlugin | null
   }
 }
 
+/**
+ * Bundles used to be cached inside the plugins folder, where the CLI listed
+ * `.cache` as an installed plugin and tried to `git pull` it. It is only a
+ * cache, so the old copy is dropped rather than migrated.
+ */
+async function removeLegacyBundleCache(pluginsDir: string): Promise<void> {
+  const legacy = join(pluginsDir, ".cache");
+  if (!existsSync(legacy)) return;
+  try {
+    await rm(legacy, { recursive: true, force: true });
+  } catch (error) {
+    log.error(`Could not remove the legacy bundle cache: ${error}`);
+  }
+}
+
 export async function collectExternalPluginBundles(): Promise<DesktopExternalPluginBundle[]> {
   const pluginsDir = getPluginsDir();
   if (!existsSync(pluginsDir)) return [];
 
-  const outDir = pluginBundleCacheDir(join(pluginsDir, ".cache"));
+  await removeLegacyBundleCache(pluginsDir);
+  const outDir = pluginBundleCacheDir(getPluginCacheDir());
   const bundles: DesktopExternalPluginBundle[] = [];
 
   for (const entry of await readdir(pluginsDir, { withFileTypes: true })) {
-    if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
+    if (!entry.isDirectory() || !isPluginDirectory(entry.name)) continue;
     const pluginDir = join(pluginsDir, entry.name);
 
     const entryFile = await resolvePluginEntry(pluginDir);

package/src/renderers/electrobun/view/build-assets.ts

@@ -23,8 +23,6 @@ const COMMON_ALIAS_RULES: AliasRule[] = [
   ["./kitty/support", "components/chart/native/renderer-selection.ts", "native-stubs/chart/kitty-support.ts"],
   ["native/surface/manager", "native-stubs/chart/surface-manager.ts"],
   ["native/surface/sync", "native-stubs/chart/surface-sync.ts"],
-  ["./native-loader", "plugins/broker-sync/robinhood.ts", "native-stubs/broker-sync-native-loader.ts"],
-  ["./native-loader", "plugins/broker-sync/simplefin.ts", "native-stubs/broker-sync-native-loader.ts"],
 ];
 
 export function electrobunViewPath(...parts: string[]): string {

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

@@ -26,6 +26,7 @@ import {
   getPresetResolution,
   normalizeChartResolutionSupport,
   TIME_RANGE_ORDER,
+  type ManualChartResolution,
 } from "../../../time-series/resolution";
 import type { TimeRange } from "../../../components/chart/core/types";
 import type { AppConfig } from "../../../types/config";
@@ -35,7 +36,7 @@ import type {
 } from "../../../core/app-service-ports";
 import type { CachedResourceRecord, ResourceCacheKey, SetResourceOptions } from "../../../data/resource-store";
 import type { CachedFinancialsTarget, DataProvider, QuoteSubscriptionTarget } from "../../../types/data-provider";
-import type { OptionsChain, TickerFinancials } from "../../../types/financials";
+import type { OptionsChain, PricePoint, TickerFinancials } from "../../../types/financials";
 import type { TickerRecord } from "../../../types/ticker";
 import type { AppState, PaneRuntimeState } from "../../../core/state/app/state";
 import type { PaneDef } from "../../../types/plugin";
@@ -50,6 +51,19 @@ import { chartSeriesSourceKey } from "../../../capabilities";
 import { apiClient, setCloudApiFetchTransport } from "../../../api-client";
 import { createGloomberbCloudProvider } from "../../../sources/gloomberb-cloud";
 
+interface CliPaneShotIntradayHistory {
+  symbol: string;
+  exchange: string;
+  rangePreset: "1D" | "1W";
+  resolution: ManualChartResolution;
+  requestedSession: string | null;
+  sessionDates: string[];
+  points: PricePoint[];
+  start: string | null;
+  end: string | null;
+  unavailableReason: string | null;
+}
+
 interface CliPaneShotPayload {
   config: AppConfig;
   paneId: string;
@@ -57,6 +71,7 @@ interface CliPaneShotPayload {
   heightCells: number;
   tickers: TickerRecord[];
   financials: Array<[string, TickerFinancials]>;
+  intradayHistories: CliPaneShotIntradayHistory[];
   optionsChains: Array<[string, OptionsChain]>;
   fredSeries: Array<[string, FredSeriesCacheEntry]>;
   valuationSeries: Array<[string, DatedObservation[]]>;
@@ -187,8 +202,11 @@ function isShotLoadingTextVisible(): boolean {
  * price presets passed.
  */
 function revivePayloadDates(payload: CliPaneShotPayload): void {
-  for (const [, data] of payload.financials) {
-    const history = data.priceHistory;
+  const histories = [
+    ...payload.financials.map(([, data]) => data.priceHistory),
+    ...(payload.intradayHistories ?? []).map((entry) => entry.points),
+  ];
+  for (const history of histories) {
     if (!Array.isArray(history)) continue;
     for (const point of history) {
       if (!(point.date instanceof Date)) point.date = new Date(point.date as unknown as string);
@@ -266,6 +284,16 @@ function createShotDataProvider(payload: CliPaneShotPayload): DataProvider {
     financials.set(canonicalTickerKey(instrument.symbol, instrument.exchange), data);
     if (!instrument.exchange) financials.set(normalizeSymbol(instrument.symbol), data);
   }
+  const intradayHistories = new Map<string, CliPaneShotIntradayHistory>();
+  for (const entry of payload.intradayHistories ?? []) {
+    intradayHistories.set(canonicalTickerKey(entry.symbol, entry.exchange), entry);
+    intradayHistories.set(normalizeSymbol(entry.symbol), entry);
+  }
+  const intradayHistory = (symbol: string, exchange?: string) => (
+    intradayHistories.get(canonicalTickerKey(symbol, exchange))
+      ?? intradayHistories.get(normalizeSymbol(symbol))
+  );
+
   const optionsChains = new Map<string, OptionsChain>();
   for (const [key, data] of payload.optionsChains ?? []) {
     const instrument = parsePublicTickerKey(key);
@@ -345,14 +373,39 @@ function createShotDataProvider(payload: CliPaneShotPayload): DataProvider {
       return resolveShotWork(null);
     },
     getPriceHistory(ticker, exchange, range) {
-      return trackShotWork(Promise.resolve().then(() => (
-        clipPriceHistoryToRange(getFinancials(ticker, exchange).priceHistory ?? [], range)
-      )));
+      return trackShotWork(Promise.resolve().then(() => {
+        const intraday = intradayHistory(ticker, exchange);
+        if (intraday?.unavailableReason) throw new Error(intraday.unavailableReason);
+        return clipPriceHistoryToRange(
+          intraday ? intraday.points : getFinancials(ticker, exchange).priceHistory ?? [],
+          range,
+        );
+      }));
+    },
+    getPriceHistoryForResolution(ticker, exchange, bufferRange, resolution) {
+      return trackShotWork(Promise.resolve().then(() => {
+        const intraday = intradayHistory(ticker, exchange);
+        if (intraday?.unavailableReason) throw new Error(intraday.unavailableReason);
+        if (intraday && intraday.resolution !== resolution) return [];
+        return clipPriceHistoryToRange(
+          intraday ? intraday.points : getFinancials(ticker, exchange).priceHistory ?? [],
+          bufferRange,
+        );
+      }));
     },
-    getPriceHistoryForResolution(ticker, exchange, bufferRange) {
-      return trackShotWork(Promise.resolve().then(() => (
-        clipPriceHistoryToRange(getFinancials(ticker, exchange).priceHistory ?? [], bufferRange)
-      )));
+    getDetailedPriceHistory(ticker, exchange, startDate, endDate, resolution) {
+      return trackShotWork(Promise.resolve().then(() => {
+        const intraday = intradayHistory(ticker, exchange);
+        if (intraday?.unavailableReason) throw new Error(intraday.unavailableReason);
+        if (intraday && intraday.resolution !== resolution) return [];
+        const start = startDate.getTime();
+        const end = endDate.getTime();
+        const points = intraday?.points ?? getFinancials(ticker, exchange).priceHistory ?? [];
+        return points.filter((point) => {
+          const timestamp = point.date.getTime();
+          return timestamp >= start && timestamp < end;
+        });
+      }));
     },
     getChartResolutionSupport() {
       return resolveShotWork(SHOT_CHART_RESOLUTION_SUPPORT);

package/src/sources/gloomberb-cloud/news.ts

@@ -85,6 +85,7 @@ export function mapCloudNewsArticle(
     importance: scores.importance,
     isBreaking: !!item.flags?.breaking,
     isDeveloping: !!item.flags?.developing,
+    sourceCount: item.sourceCount,
     items: item.items?.map(mapCloudNewsStoryItem) ?? [],
   };
 }

package/src/sync/core-contributors.test.ts

@@ -129,6 +129,99 @@ describe("core sync contributors", () => {
     }
   });
 
+  test("preserves local broker identity when applying sanitized portfolios", () => {
+    const config = createDefaultConfig("/tmp/gloomberb-sync-broker-identity-test");
+    config.portfolios = [{
+      id: "broker:demo-live:ACCOUNT-1",
+      name: "Primary",
+      currency: "USD",
+      brokerId: "demo",
+      brokerInstanceId: "demo-live",
+      brokerAccountId: "ACCOUNT-1",
+      lastSyncedAt: 100,
+    }];
+
+    const collected = __syncContributorInternalsForTests.collectCoreConfigPayload(config) as {
+      portfolios: Array<Record<string, unknown>>;
+    };
+    expect(collected.portfolios[0]).not.toHaveProperty("brokerInstanceId");
+    expect(collected.portfolios[0]).not.toHaveProperty("brokerAccountId");
+
+    const merged = __syncContributorInternalsForTests.mergeConfigPayload(config, {
+      portfolios: [{
+        id: "broker:demo-live:ACCOUNT-1",
+        name: "Primary",
+        currency: "USD",
+        brokerId: "demo",
+        lastSyncedAt: 200,
+      }],
+    });
+
+    expect(merged?.portfolios).toEqual([{
+      id: "broker:demo-live:ACCOUNT-1",
+      name: "Primary",
+      currency: "USD",
+      brokerId: "demo",
+      brokerInstanceId: "demo-live",
+      brokerAccountId: "ACCOUNT-1",
+      lastSyncedAt: 200,
+    }]);
+  });
+
+  test("does not reintroduce older unlinked broker portfolios from cloud", () => {
+    const config = createDefaultConfig("/tmp/gloomberb-sync-broker-identity-test");
+    config.portfolios = [
+      {
+        id: "main",
+        name: "Main",
+        currency: "USD",
+      },
+      {
+        id: "broker:demo-live:ACCOUNT-1",
+        name: "Primary",
+        currency: "USD",
+        brokerId: "demo",
+        brokerInstanceId: "demo-live",
+        brokerAccountId: "ACCOUNT-1",
+        lastSyncedAt: 200,
+      },
+      {
+        id: "broker:demo-live:ACCOUNT-2",
+        name: "Secondary",
+        currency: "USD",
+        brokerId: "demo",
+        brokerInstanceId: "demo-live",
+        brokerAccountId: "ACCOUNT-2",
+        lastSyncedAt: 200,
+      },
+    ];
+
+    const merged = __syncContributorInternalsForTests.mergeConfigPayload(config, {
+      portfolios: [
+        { id: "main", name: "Main", currency: "USD" },
+        { id: "broker:demo-live:ACCOUNT-1", name: "Primary", currency: "USD", brokerId: "demo", lastSyncedAt: 200 },
+        { id: "broker:demo-live:ACCOUNT-2", name: "Secondary", currency: "USD", brokerId: "demo", lastSyncedAt: 200 },
+        { id: "broker:demo-old:ACCOUNT-1", name: "Primary", currency: "USD", brokerId: "demo", lastSyncedAt: 100 },
+        { id: "broker:demo-old:ACCOUNT-2", name: "Secondary", currency: "USD", brokerId: "demo", lastSyncedAt: 100 },
+        { id: "broker:demo-old:REMOVED", name: "Removed", currency: "USD", brokerId: "demo", lastSyncedAt: 100 },
+        { id: "broker:demo-other:ACCOUNT-3", name: "Remote", currency: "USD", brokerId: "demo", lastSyncedAt: 300 },
+      ],
+    });
+
+    expect(merged?.portfolios).toEqual([
+      config.portfolios[0],
+      config.portfolios[1],
+      config.portfolios[2],
+      {
+        id: "broker:demo-other:ACCOUNT-3",
+        name: "Remote",
+        currency: "USD",
+        brokerId: "demo",
+        lastSyncedAt: 300,
+      },
+    ]);
+  });
+
   test("keeps resumable onboarding local until the guide is complete", async () => {
     const config = createDefaultConfig("/tmp/gloomberb-sync-test");
     config.onboardingComplete = false;
@@ -258,6 +351,24 @@ describe("core sync contributors", () => {
     expect((payload as any).tickers[0].quote.weekReferencePrice).toBe(125);
     expect((payload as any).tickers[0].quote.weekChangePercent).toBe(20);
     expect((payload as any).analyticsByPortfolio.main.oneYearReturn).toBe(0.42);
+
+    const saved: TickerRecord[] = [];
+    const sanitizedTickerPayload = { tickers: (payload as any).tickers };
+    await coreCollectionsSyncContributor.apply?.(sanitizedTickerPayload, {
+      baselinePayload: sanitizedTickerPayload,
+      baselineState: state,
+      state,
+      getState: () => state,
+      isCurrent: () => true,
+      dispatch: () => {},
+      tickerRepository: { saveTicker: async (record: TickerRecord) => { saved.push(record); } },
+    } as unknown as Parameters<NonNullable<typeof coreCollectionsSyncContributor.apply>>[1]);
+
+    expect(saved[0]?.metadata.positions[0]).toMatchObject({
+      brokerInstanceId: "broker-id",
+      brokerAccountId: "account-id",
+      brokerContractId: 42,
+    });
   });
 
   test("keeps a position written while the app was closed", async () => {

package/src/sync/core-contributors.ts

@@ -58,6 +58,116 @@ function sanitizePortfolio(portfolio: Portfolio): Portfolio {
   };
 }
 
+function brokerAccountIdFromPortfolioId(portfolioId: string): string | undefined {
+  const [kind, instanceId, ...accountParts] = portfolioId.split(":");
+  if (kind !== "broker" || !instanceId) return undefined;
+  const accountId = accountParts.join(":").trim();
+  return accountId && accountId !== "default" ? accountId : undefined;
+}
+
+function brokerPortfolioKey(brokerId: string | undefined, accountId: string | undefined): string | undefined {
+  if (!brokerId || !accountId) return undefined;
+  return [brokerId, accountId].join("\u0000");
+}
+
+function portfolioSyncTimestamp(portfolio: Portfolio): number {
+  return typeof portfolio.lastSyncedAt === "number" && Number.isFinite(portfolio.lastSyncedAt)
+    ? portfolio.lastSyncedAt
+    : 0;
+}
+
+function latestBrokerSyncByType(portfolios: Portfolio[], linkedOnly: boolean): Map<string, number> {
+  const latest = new Map<string, number>();
+  for (const portfolio of portfolios) {
+    if (!portfolio.brokerId || (linkedOnly && !portfolio.brokerInstanceId)) continue;
+    const timestamp = portfolioSyncTimestamp(portfolio);
+    latest.set(portfolio.brokerId, Math.max(latest.get(portfolio.brokerId) ?? 0, timestamp));
+  }
+  return latest;
+}
+
+/**
+ * Broker identity is deliberately excluded from cloud payloads, but it is
+ * still local state that must survive applying a sanitized portfolio back to
+ * this device. Match by the stable portfolio ID first, then by the account
+ * suffix in that stable ID. A newer local broker snapshot also wins over old
+ * unlinked records left in a cloud snapshot from before a reset.
+ */
+function mergeLocalBrokerPortfolioIdentity(
+  localPortfolios: Portfolio[],
+  syncedPortfolios: Portfolio[],
+): Portfolio[] {
+  const localById = new Map(localPortfolios.map((portfolio) => [portfolio.id, portfolio] as const));
+  const localByBrokerAccount = new Map<string, Portfolio[]>();
+  for (const portfolio of localPortfolios) {
+    if (!portfolio.brokerInstanceId) continue;
+    const key = brokerPortfolioKey(portfolio.brokerId, portfolio.brokerAccountId);
+    if (!key) continue;
+    const entries = localByBrokerAccount.get(key) ?? [];
+    entries.push(portfolio);
+    localByBrokerAccount.set(key, entries);
+  }
+
+  const exactIncomingIds = new Set(
+    syncedPortfolios
+      .map((portfolio) => portfolio.id)
+      .filter((portfolioId) => localById.has(portfolioId)),
+  );
+  const localLatestByBroker = latestBrokerSyncByType(localPortfolios, true);
+  const syncedLatestByBroker = latestBrokerSyncByType(syncedPortfolios, false);
+  const merged: Portfolio[] = [];
+  const seenIds = new Set<string>();
+
+  for (const portfolio of syncedPortfolios) {
+    const localByStableId = localById.get(portfolio.id);
+    const accountId = brokerAccountIdFromPortfolioId(portfolio.id);
+    const accountCandidates = localByBrokerAccount.get(brokerPortfolioKey(portfolio.brokerId, accountId) ?? "");
+    const local = localByStableId?.brokerInstanceId && localByStableId.brokerId === portfolio.brokerId
+      ? localByStableId
+      : accountCandidates?.length === 1
+        ? accountCandidates[0]
+        : undefined;
+
+    if (local) {
+      // Prefer an exact stable-ID entry when an older duplicate appears first
+      // in the remote array.
+      if (portfolio.id !== local.id && exactIncomingIds.has(local.id)) continue;
+      if (seenIds.has(local.id)) continue;
+
+      const localIsNewer = portfolioSyncTimestamp(local) > portfolioSyncTimestamp(portfolio);
+      merged.push(localIsNewer
+        ? local
+        : {
+          ...portfolio,
+          id: local.id,
+          brokerInstanceId: local.brokerInstanceId,
+          brokerAccountId: local.brokerAccountId,
+        });
+      seenIds.add(local.id);
+      continue;
+    }
+
+    const localLatest = portfolio.brokerId ? localLatestByBroker.get(portfolio.brokerId) : undefined;
+    if (localLatest !== undefined && localLatest > portfolioSyncTimestamp(portfolio)) continue;
+    merged.push(portfolio);
+    seenIds.add(portfolio.id);
+  }
+
+  // If the newer local broker snapshot is absent from the cloud array
+  // altogether, keep it instead of treating the older array as authoritative.
+  for (const portfolio of localPortfolios) {
+    if (!portfolio.brokerInstanceId || seenIds.has(portfolio.id)) continue;
+    const localLatest = portfolio.brokerId ? localLatestByBroker.get(portfolio.brokerId) : undefined;
+    const syncedLatest = portfolio.brokerId ? syncedLatestByBroker.get(portfolio.brokerId) ?? 0 : 0;
+    if (localLatest !== undefined && localLatest > syncedLatest) {
+      merged.push(portfolio);
+      seenIds.add(portfolio.id);
+    }
+  }
+
+  return merged;
+}
+
 function sanitizeWatchlist(watchlist: Watchlist): Watchlist {
   return {
     id: watchlist.id,
@@ -93,6 +203,38 @@ function sanitizePosition(position: TickerPosition): TickerPosition {
   };
 }
 
+function brokerPositionKey(position: Pick<TickerPosition, "portfolio" | "broker" | "side">): string {
+  return [position.portfolio, position.broker, position.side ?? ""].join("\u0000");
+}
+
+/** Keep broker position identity local while applying public cloud fields. */
+function mergeLocalBrokerPositionIdentity(
+  localPositions: TickerPosition[],
+  syncedPositions: TickerPosition[],
+): TickerPosition[] {
+  const localByKey = new Map<string, TickerPosition[]>();
+  for (const position of localPositions) {
+    if (!position.brokerInstanceId) continue;
+    const key = brokerPositionKey(position);
+    const entries = localByKey.get(key) ?? [];
+    entries.push(position);
+    localByKey.set(key, entries);
+  }
+
+  return syncedPositions.map((position) => {
+    const entries = localByKey.get(brokerPositionKey(position));
+    const local = entries?.shift();
+    if (!local) return position;
+
+    return {
+      ...position,
+      brokerInstanceId: local.brokerInstanceId,
+      brokerAccountId: local.brokerAccountId,
+      brokerContractId: local.brokerContractId,
+    };
+  });
+}
+
 function pricePointTime(point: { date: Date | string | number }): number {
   const value = point.date;
   if (value instanceof Date) return value.getTime();
@@ -405,7 +547,12 @@ function mergeConfigPayload(
 
   assign("baseCurrency");
   assign("refreshIntervalMinutes");
-  assign("portfolios");
+  if ("portfolios" in payload && canApply("portfolios")) {
+    const syncedPortfolios = payload.portfolios;
+    next.portfolios = Array.isArray(syncedPortfolios)
+      ? mergeLocalBrokerPortfolioIdentity(config.portfolios, syncedPortfolios as Portfolio[])
+      : syncedPortfolios as AppConfig["portfolios"];
+  }
   assign("watchlists");
   assign("disabledSources");
   assign("theme");
@@ -532,9 +679,16 @@ export const coreCollectionsSyncContributor: SyncContributor = {
       // Local edits the cloud has never seen (CLI positions, offline changes)
       // win here and are uploaded by the push that follows this pull.
       if (tickerChangedSinceLastSync(current, lastSyncedTickers)) continue;
+      const syncedPositions = Array.isArray(rawTicker.positions)
+        ? mergeLocalBrokerPositionIdentity(
+          current?.metadata.positions ?? [],
+          rawTicker.positions as TickerPosition[],
+        )
+        : current?.metadata.positions ?? [];
       const metadata = hydrateTickerMetadata({
         ...current?.metadata,
         ...rawTicker,
+        positions: syncedPositions,
         broker_contracts: current?.metadata.broker_contracts ?? [],
       });
       const record: TickerRecord = { metadata };

package/src/time-series/resolve.test.ts

@@ -3,7 +3,12 @@ import type { FredSeriesData, FredSeriesLoadResult } from "../data/fred-series";
 import { createTestDataProvider } from "../test-support/data-provider";
 import type { TickerFinancials } from "../types/financials";
 import { CHART_SPEC_VERSION, type ChartSpec } from "./types";
-import { ChartResolveCache, mergePriceHistoryWindows, resolveChartSpecData } from "./resolve";
+import {
+  ChartResolveCache,
+  mergePriceHistoryWindows,
+  resolveChartSpecData,
+  seedChartResolutionResult,
+} from "./resolve";
 import { chartQuoteOverrideKeyForSource } from "./live-quotes";
 import { chartSeriesSourceKey } from "../capabilities";
 import { buildCustomChartPreset } from "../plugins/builtin/chart-composer/presets";
@@ -26,6 +31,118 @@ const fredLoad = (
 });
 
 describe("resolveChartSpecData", () => {
+  test("seeds study series so their panels survive the wait for real data", async () => {
+    const date = new Date("2026-01-05T00:00:00.000Z");
+    const seeded = seedChartResolutionResult(
+      {
+        version: CHART_SPEC_VERSION,
+        viewport: { range: "1M", resolution: "auto" },
+        panels: [{ id: "main" }, { id: "volume" }],
+        series: [{
+          id: "price",
+          source: {
+            kind: "security",
+            instrument: { symbol: "TEST", exchange: "NASDAQ" },
+            fieldId: "market.ohlcv",
+          },
+          style: "candles",
+          transform: "raw",
+          axis: "left",
+          panelId: "main",
+          interpolation: "none",
+        }],
+        studies: [{
+          id: "volume",
+          kind: "volume",
+          inputSeriesIds: ["price"],
+          parameters: {},
+          panelId: "volume",
+          axis: "left",
+        }],
+      },
+      new Map([[
+        chartQuoteOverrideKeyForSource({
+          kind: "security",
+          instrument: { symbol: "TEST", exchange: "NASDAQ" },
+          fieldId: "market.ohlcv",
+        }),
+        [{ date, open: 10, high: 12, low: 9, close: 11, volume: 5_000 }],
+      ]]),
+    );
+
+    const volume = seeded?.series.find((entry) => entry.panelId === "volume");
+    expect(volume?.points.map((point) => point.value)).toEqual([5_000]);
+    expect(seeded?.bufferedSeries).toBe(seeded?.series);
+  });
+
+  test("keeps study output over the whole buffered history its base series carries", async () => {
+    const history = Array.from({ length: 900 }, (_, day) => {
+      const date = new Date(Date.UTC(2024, 0, 1) + day * 86_400_000);
+      return date.getUTCDay() === 0 || date.getUTCDay() === 6
+        ? null
+        : { date, open: 100, high: 101, low: 99, close: 100 + (day % 7), volume: 1_000 + day };
+    }).filter((point): point is NonNullable<typeof point> => point !== null);
+    const provider = createTestDataProvider({
+      getTickerFinancials: async () => emptyFinancials(),
+      getChartResolutionSupport: () => [{ resolution: "1d", maxRange: "ALL" }],
+      getPriceHistoryForResolution: async () => history,
+      getDetailedPriceHistory: async () => history,
+    });
+    const spec: ChartSpec = {
+      version: CHART_SPEC_VERSION,
+      viewport: { range: "1Y", resolution: "1d" },
+      panels: [{ id: "main" }, { id: "volume", label: "Volume", height: 0.24 }],
+      series: [{
+        id: "price",
+        source: {
+          kind: "security",
+          instrument: { symbol: "TEST", exchange: "NASDAQ" },
+          fieldId: "market.close",
+        },
+        style: "line",
+        transform: "raw",
+        axis: "left",
+        panelId: "main",
+        interpolation: "none",
+      }],
+      studies: [{
+        id: "volume",
+        kind: "volume",
+        inputSeriesIds: ["price"],
+        parameters: {},
+        panelId: "volume",
+        axis: "left",
+      }],
+    };
+    const sources = {
+      dataProvider: provider,
+      now: new Date("2026-06-15T00:00:00.000Z"),
+      loadFredSeries: async () => fredLoad(),
+    };
+    const cache = new ChartResolveCache();
+
+    await resolveChartSpecData(spec, sources, cache);
+    // Panning back accumulates older bars into the buffer. The study has to
+    // follow, or it empties out wherever the base series has already been.
+    const panned = await resolveChartSpecData(spec, sources, cache, {
+      requestViewport: {
+        start: new Date("2024-02-01T00:00:00.000Z"),
+        end: new Date("2024-08-01T00:00:00.000Z"),
+      },
+    });
+
+    const span = (id: string) => {
+      const entry = panned.bufferedSeries?.find((candidate) => candidate.id === id);
+      return entry && entry.points.length > 0
+        ? {
+            first: entry.points[0]!.date.toISOString(),
+            last: entry.points.at(-1)!.date.toISOString(),
+          }
+        : null;
+    };
+    expect(span("volume")).toEqual(span("price"));
+  });
+
   test("routes futures and Treasury aliases through the existing market and FRED pipelines", async () => {
     const marketRequests: string[] = [];
     const fredRequests: string[] = [];