gloomberb 0.18.1 → 0.18.2

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

@@ -45,6 +45,7 @@ import { isRoundTheClockCoin } from "../../utils/crypto-pair";
 import { canonicalExchange, canonicalTickerKey, parsePublicTickerKey } from "../../utils/exchanges";
 import { normalizePriceHistory, priceHistoryIntervalMs, reachesLatestSettledSession } from "../../utils/price-history";
 import { createProviderMiss, ProviderBusyError, providerMissReason } from "../provider-errors";
+import { parseListingDelisting } from "../../market-data/quotes/delisting";
 import { isRetryableApiError } from "../../api-client/errors";
 import { assertSecRegistrantMatches } from "../sec-registrant";
 import { nonUsSecListingVenue } from "../../utils/sec";
@@ -251,9 +252,11 @@ function mapCloudPriceHistory(
   }
   // Sessions of daily bars the answer left out for a close at or below zero.
   const nonPositiveCloseDates = resolution === "1d" ? cloudNonPositiveCloseDates(response.omittedSessions) : undefined;
+  const delisting = parseListingDelisting(response.delisting);
   return {
     points,
     resolution,
+    ...(delisting ? { delisting } : {}),
     ...(session && matchingSource && matchingIdentity ? { session } : {}),
     ...(nonPositiveCloseDates ? { nonPositiveCloseDates } : {}),
     ...(coverageStart ? { coverageStart } : {}),
@@ -262,6 +265,28 @@ function mapCloudPriceHistory(
   };
 }
 
+const DAY_MS = 86_400_000;
+/** Listings Gloom Cloud said no longer trade, by listing key: the day after each one's last session. */
+const delistedHistoryEnds = new Map<string, Date>();
+
+/**
+ * Where a trailing window ends for a listing that no longer trades: the day
+ * after its last session, as a window ending now ends the day after today's.
+ * A window ending now would hold none of its bars, or only the last few.
+ */
+function delistedHistoryEnd(response: CloudMarketResponse<unknown>, key: string): Date | null {
+  const delisting = parseListingDelisting(response.delisting);
+  if (!delisting) {
+    // The symbol trades again (another issuer took it): its windows end now.
+    delistedHistoryEnds.delete(key);
+    return null;
+  }
+  const end = new Date(Date.parse(`${delisting.lastTradeDate}T00:00:00Z`) + DAY_MS);
+  if (delistedHistoryEnds.size >= 1024) delistedHistoryEnds.clear();
+  delistedHistoryEnds.set(key, end);
+  return end;
+}
+
 function cloudHistoryResolution(interval: string): ManualChartResolution | null {
   const canonical = canonicalHistoryInterval(interval);
   return (["1m", "5m", "15m", "30m", "1h", "1d", "1wk", "1mo"] as const)
@@ -549,14 +574,14 @@ export class GloomberbCloudProvider implements AssetDataProvider {
         // A successful batch can contain an expired cache fallback for only
         // one listing. Match the single-quote freshness boundary and let the
         // normal router retry that item without discarding its healthy peers.
-        if (item.stale === true) {
+        // A listing that no longer trades has only that last quote: kept, flagged stale.
+        const delisted = !!parseListingDelisting(item.data?.delisting);
+        if (item.stale === true && !delisted) {
           return { target, quote: null, error: createProviderMiss(`Cloud quotes are stale for ${target.symbol}`) };
         }
         if ((item.status === "success" || item.status === "partial") && item.data) {
-          return {
-            target,
-            quote: retainRequestedQuoteSymbol(mapQuote(item.data), target.symbol),
-          };
+          const quote = retainRequestedQuoteSymbol(mapQuote(item.data), target.symbol);
+          return { target, quote: item.stale === true ? { ...quote, stale: true } : quote };
         }
         return {
           target,
@@ -778,19 +803,27 @@ export class GloomberbCloudProvider implements AssetDataProvider {
     const target = cloudInstrumentTarget(ticker, exchange);
     exchange = target.exchange ?? "";
     const interval = toCloudInterval(resolution);
-    const endDate = new Date();
-    const startDate = subtractTimeRange(endDate, bufferRange);
     const includeTime = /^\d+(min|h)$/i.test(interval);
-    const { response, extendedHours } = await withCloudFallback(
-      () => loadCloudHistory(interval, (session) => apiClient.getCloudHistory(target.symbol, exchange, {
-        interval,
-        startDate: formatCloudDateTime(startDate, includeTime, exchange),
-        endDate: formatCloudHistoryEnd(endDate, includeTime, exchange),
-        ...(session ? { session } : {}),
-      }), _context),
-      `Cloud chart data is unavailable for ${ticker}`,
-    );
-    return mapCloudPriceHistory(response, target.symbol, exchange, interval, startDate, endDate, extendedHours);
+    const listingKey = canonicalTickerKey(target.symbol, exchange);
+    const load = (endDate: Date) => {
+      const startDate = subtractTimeRange(endDate, bufferRange);
+      return withCloudFallback(
+        () => loadCloudHistory(interval, (session) => apiClient.getCloudHistory(target.symbol, exchange, {
+          interval,
+          startDate: formatCloudDateTime(startDate, includeTime, exchange),
+          endDate: formatCloudHistoryEnd(endDate, includeTime, exchange),
+          ...(session ? { session } : {}),
+        }), _context),
+        `Cloud chart data is unavailable for ${ticker}`,
+      ).then((answer) => ({ ...answer, startDate, endDate }));
+    };
+    // A listing that no longer trades is read up to its last session, not up to now.
+    const knownEnd = delistedHistoryEnds.get(listingKey);
+    const now = new Date();
+    let answer = await load(knownEnd ?? now);
+    const delistedEnd = delistedHistoryEnd(answer.response, listingKey);
+    if (delistedEnd ? delistedEnd.getTime() < answer.endDate.getTime() : knownEnd) answer = await load(delistedEnd ?? now);
+    return mapCloudPriceHistory(answer.response, target.symbol, exchange, interval, answer.startDate, answer.endDate, answer.extendedHours);
   }
 
   async getDetailedPriceHistory(

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

@@ -27,6 +27,7 @@ import { createProviderMiss } from "../provider-errors";
 import { reconcileQuoteDayRange } from "../../market-data/quotes/day-range";
 import { redactUnavailableFundamentals } from "../../utils/fundamentals";
 import { readWithdrawnObservations } from "../../utils/statement-gaps";
+import { parseListingDelisting } from "../../market-data/quotes/delisting";
 
 export const GLOOMBERB_CLOUD_PROVIDER_ID = "gloomberb-cloud" as const;
 
@@ -94,6 +95,7 @@ export function mapQuote(
     : futuresBasis ?? quote.priceBasis;
   return withoutUndefinedFields(reconcileQuoteDayRange({
     ...quote,
+    delisting: parseListingDelisting(quote.delisting),
     priceBasis,
     priceObservation,
     currency: currency || quote.currency,
@@ -130,6 +132,8 @@ export function mapQuote(
       divisor,
     ),
     extendedSessionPrint: typeof quote.extendedSessionPrint === "boolean" ? quote.extendedSessionPrint : undefined,
+    // A coin's move over 24 hours, or none, when its previous close is undatable.
+    changeBasis: quote.changeBasis === "24h" || quote.changeBasis === "none" ? quote.changeBasis : undefined,
     overnightPrice: normalizePriceValueByDivisor(quote.overnightPrice, divisor),
     overnightChange: normalizePriceValueByDivisor(quote.overnightChange, divisor),
     overnightPriceKind: quote.overnightPriceKind === "trade" || quote.overnightPriceKind === "mark"

package/src/sources/history-result.ts

@@ -6,6 +6,7 @@ import { parseHistorySession } from "../market-data/history-session";
 import { canonicalHistoryInterval } from "./history-retention";
 import { historyCoverageNoteText, isHistoryCoverageDate } from "./history-coverage";
 import { readNonPositiveCloseDates } from "./history-omitted";
+import { parseListingDelisting } from "../market-data/quotes/delisting";
 
 export type HistoryResultRequest =
   | { kind: "range"; range: TimeRange }
@@ -38,6 +39,7 @@ export function normalizeHistoryResult(
   // A contradictory declaration cannot be laundered into unknown legacy data.
   if (result.session != null && (!session || result.resolution === null)) return null;
   const nonPositiveCloseDates = readNonPositiveCloseDates(result.nonPositiveCloseDates);
+  const delisting = parseListingDelisting(result.delisting);
   return { points: result.points, resolution: result.resolution,
     ...(session ? { session } : {}),
     ...(nonPositiveCloseDates ? { nonPositiveCloseDates } : {}),
@@ -47,6 +49,7 @@ export function normalizeHistoryResult(
       ? { coverageNote: historyCoverageNoteText(result.coverageNote) } : {}),
     ...(result.extendedHours === true ? { extendedHours: true } : {}),
     ...(result.savedCopyBehind === true ? { savedCopyBehind: true as const } : {}),
+    ...(delisting ? { delisting } : {}),
   };
 }
 

package/src/sources/provider-errors.ts

@@ -1,4 +1,6 @@
-const PROVIDER_MISS_BRAND = Symbol("provider-miss");
+// Registered, so a miss raised by another copy of this module (a plugin that
+// resolved `gloomberb/market-data` from the source tree) is still recognized.
+const PROVIDER_MISS_BRAND = Symbol.for("gloomberb.provider-miss");
 const EXPECTED_PROVIDER_MISS = /No data found|symbol may be delisted|"code":"Not Found"|No history for /i;
 
 const MAX_REASON_LENGTH = 200;

package/src/sources/provider-router/history.ts

@@ -4,6 +4,7 @@ import { canonicalHistoryInterval, HistoryRetentionError, isHistoryRetentionErro
   type HistoryRecoveryCandidate, type HistoryRetention, type HistorySourceOutcome } from "../history-retention";
 import type { BrokerCandidate } from "./brokers";
 import { withBrokerTimeout } from "./brokers";
+import type { BrokerHistoryOptions } from "../../types/broker";
 import type { DataProvider, MarketDataRequestContext } from "../../types/data-provider";
 import type { PriceHistoryResult } from "../../types/price-history";
 import { fetchHistoryResult, historyResolutionForInterval, InvalidHistoryResultError, normalizeHistoryResult } from "../history-result";
@@ -244,6 +245,29 @@ function mergeRequestHistoryGaps(
   })));
 }
 
+/** The extended session goes only to a broker that serves it, and only when the chart asked. */
+function brokerHistoryOptions(candidate: BrokerCandidate, context?: MarketDataRequestContext): [BrokerHistoryOptions] | [] {
+  return context?.historySession === "extended" && candidate.broker.extendedHoursHistory === true ? [{ session: "extended" }] : [];
+}
+
+/**
+ * With Ext hours on, a broker that serves only the regular session answers
+ * after the market-data providers, which may hold the extended session; it is
+ * still the last resort before nothing. Otherwise the order is unchanged.
+ */
+function brokersForSession(candidates: BrokerCandidate[], context?: MarketDataRequestContext): { first: BrokerCandidate[]; last: BrokerCandidate[] } {
+  if (context?.historySession !== "extended") return { first: candidates, last: [] };
+  return {
+    first: candidates.filter((candidate) => candidate.broker.extendedHoursHistory === true),
+    last: candidates.filter((candidate) => candidate.broker.extendedHoursHistory !== true),
+  };
+}
+
+function isIntradayInterval(interval: string | undefined): boolean {
+  const ms = interval ? priceHistoryIntervalMs(interval) : null;
+  return ms != null && ms < 24 * 60 * 60 * 1000;
+}
+
 function normalizeRequestResult(value: PriceHistoryResult, request: HistoryRequestDescriptor): PriceHistoryResult {
   // Only this router says a copy is behind, when it answers: neither a source
   // nor a stored copy can carry that verdict in.
@@ -254,8 +278,12 @@ function normalizeRequestResult(value: PriceHistoryResult, request: HistoryReque
   };
 }
 
-/** A copy fetched at `fetchedAt`, now for a source's answer. */
+/**
+ * A copy fetched at `fetchedAt`, now for a source's answer. A listing that no
+ * longer trades is never behind: its bars end on its last session for good.
+ */
 function resultIsStale(value: PriceHistoryResult, symbol: string, exchange: string, fetchedAt: number, intervalMs?: number | null): boolean {
+  if (value.delisting) return false;
   return isPriceHistoryStaleForCurrentWindow(value.points, Date.now(), {
     symbol, exchange, intervalMs: intervalMs ?? (value.resolution ? priceHistoryIntervalMs(value.resolution) : undefined), session: value.session,
     fetchedAt,
@@ -425,6 +453,7 @@ export class ProviderRouterHistoryRoutes {
           bufferRange,
           resolution,
           context?.instrument ?? null,
+          ...brokerHistoryOptions(candidate, context),
         )
         : null,
       fetchProvider: (provider) => fetchHistoryResult(provider, ticker, exchange, { kind: "resolution", range: bufferRange, resolution }, context),
@@ -543,6 +572,7 @@ export class ProviderRouterHistoryRoutes {
           endDate,
           barSize,
           context?.instrument ?? null,
+          ...brokerHistoryOptions(candidate, context),
         )
         : null,
       fetchProvider: (provider) => fetchHistoryResult(provider, ticker, exchange, { kind: "detail", start: startDate, end: endDate, interval: barSize }, context),
@@ -551,10 +581,13 @@ export class ProviderRouterHistoryRoutes {
 
   private async executeHistoryRequest(request: HistoryRequestDescriptor): Promise<PriceHistoryResult> {
     const recovery = this.validateRecovery(request);
-    const brokerCandidates = recovery ? [] : this.deps.getBrokerCandidatesForContext(request.context, false);
+    const { first: brokerCandidates, last: regularSessionBrokers } = brokersForSession(
+      recovery ? [] : this.deps.getBrokerCandidatesForContext(request.context, false), request.context);
+    // Cached copies rank in the order the sources are asked.
     const sourceKeys = recovery ? [recovery.sourceKey] : [
       ...brokerCandidates.map((candidate) => this.deps.brokerSourceKey(candidate)),
       ...this.deps.getProviderSourceKeys(),
+      ...regularSessionBrokers.map((candidate) => this.deps.brokerSourceKey(candidate)),
     ];
     const cachedRecords = listCachedResources<unknown>(
       this.deps.resources,
@@ -584,6 +617,7 @@ export class ProviderRouterHistoryRoutes {
     const currentWindow = request.requestedEnd === undefined || isCurrentHistoryWindow(new Date(request.requestedEnd));
     const now = Date.now();
     const fetchState = (record: { fetchedAt: number; value: PriceHistoryResult }, checkedAt?: number): CalendarHistoryFetchState => currentWindow
+      && !record.value.delisting
       ? calendarHistoryFetchState(record.value.points, record.fetchedAt, now, {
         symbol: target.symbol,
         exchange: target.exchange || request.target.exchange,
@@ -661,6 +695,12 @@ export class ProviderRouterHistoryRoutes {
     });
     if (providerResult && hasUsablePriceHistory(providerResult.value.points)) return withReportedGaps(providerResult.value);
     if (providerResult) reportedGaps.push(providerResult.value);
+    if (regularSessionBrokers.length) {
+      const regularResult = await withBrokerTimeout(this.fetchBrokerHistory(request, regularSessionBrokers, onUnavailable, attempts));
+      for (const sourceKey of [...attempts.pending]) recordHistoryOutcome(attempts, sourceKey, "timeout");
+      if (regularResult && hasUsablePriceHistory(regularResult.value.points)) return withReportedGaps(regularResult.value);
+      if (regularResult) reportedGaps.push(regularResult.value);
+    }
     // A failed refetch falls back in the same order the cache hit used, so a
     // failing request answers what the next request will: a current copy
     // first, else a saved copy short of the latest session, which beats an
@@ -722,10 +762,12 @@ export class ProviderRouterHistoryRoutes {
   private async refreshHistory(request: HistoryRequestDescriptor): Promise<void> {
     try {
       const recovery = this.validateRecovery(request);
-      const brokerCandidates = recovery ? [] : this.deps.getBrokerCandidatesForContext(request.context, false);
-      const brokerResult = await withBrokerTimeout(this.fetchBrokerHistory(request, brokerCandidates));
+      const { first, last } = brokersForSession(recovery ? [] : this.deps.getBrokerCandidatesForContext(request.context, false), request.context);
+      const brokerResult = await withBrokerTimeout(this.fetchBrokerHistory(request, first));
       if (brokerResult && hasUsablePriceHistory(brokerResult.value.points)) return;
-      await this.fetchProviderHistory(request);
+      const providerResult = await this.fetchProviderHistory(request);
+      if (providerResult && hasUsablePriceHistory(providerResult.value.points)) return;
+      if (last.length) await withBrokerTimeout(this.fetchBrokerHistory(request, last));
     } catch (error) {
       logFailure("sources.provider-router.history", "Refreshing background price history failed")(error);
     }
@@ -745,7 +787,8 @@ export class ProviderRouterHistoryRoutes {
         const fetched = await request.fetchBroker(candidate);
         if (fetched === null) { recordHistoryOutcome(attempts, sourceKey, "empty"); return null; }
         if (!Array.isArray(fetched)) { recordHistoryOutcome(attempts, sourceKey, "malformed"); return null; }
-        const value = normalizeRequestResult({ points: fetched, resolution: historyResolutionForInterval(request.interval), sourceKey }, request);
+        const value = normalizeRequestResult({ points: fetched, resolution: historyResolutionForInterval(request.interval), sourceKey,
+          ...(brokerHistoryOptions(candidate, request.context).length && isIntradayInterval(request.interval) ? { extendedHours: true } : {}) }, request);
         if (hasUsablePriceHistory(value.points) && request.isFetchedValueStale(value)) { recordHistoryOutcome(attempts, sourceKey, "stale"); return null; }
         recordHistoryOutcome(attempts, sourceKey, hasUsablePriceHistory(value.points) ? "success" : value.points.length ? "reported-gaps" : "empty");
         onUnavailable?.(this.deps.brokerSourceKey(candidate), value);

package/src/sources/provider-router/index.ts

@@ -412,7 +412,8 @@ export class AssetDataRouter implements DataProvider {
   }
 
   async getOptionsChain(ticker: string, exchange?: string, expirationDate?: number, context?: MarketDataRequestContext): Promise<OptionsChain> {
-    return (await this.getCachedQuery("getOptionsChain", [ticker, exchange, expirationDate, context]).load({ force: context?.cacheMode === "refresh", background: this.revalidateInBackground })).value;
+    return (await this.getCachedQuery("getOptionsChain", [ticker, exchange, expirationDate, context])
+      .load({ force: context?.cacheMode === "refresh", background: this.revalidateInBackground && context?.cacheMode !== "current" })).value;
   }
 
   getCachedQuery<K extends CachedAssetMethod>(method: K, args: CachedAssetArgs<K>) {

package/src/state/app/activity.ts

@@ -190,6 +190,19 @@ export function usePaneInView(): boolean {
   return useContext(PaneInViewContext);
 }
 
+/**
+ * Whether the pane around the caller is the focused one, as its frame draws
+ * it (a pane under the open command bar is not). Null outside a pane.
+ */
+const PaneFocusedContext = createContext<boolean | null>(null);
+
+export const PaneFocusedProvider = PaneFocusedContext.Provider;
+
+/** For chrome a pane shows only while focused (a chart's drawing tools); null outside a pane. */
+export function usePaneFocused(): boolean | null {
+  return useContext(PaneFocusedContext);
+}
+
 /**
  * Gate a pane's market data (stream priority, polls, refresh clocks) on this:
  * the app can be seen and the pane is on screen. A covered pane should keep

package/src/sync/controller.ts

@@ -13,6 +13,7 @@ import {
   type SyncSnapshot,
   type SyncTransport,
 } from "./types";
+import type { LocalMarketDataLookup } from "./local-only";
 
 type CloudSyncPhase = "idle" | "disabled" | "syncing" | "synced" | "error";
 
@@ -32,6 +33,8 @@ interface SyncRuntime {
   getContributors: () => RegisteredSyncContributor[];
   getTransport: () => RegisteredSyncTransport | null;
   baselineStore?: SyncBaselineStore;
+  /** Sources whose quotes and bars never leave this device (`BrokerAdapter.localMarketData`); none when absent. */
+  isLocalMarketData?: LocalMarketDataLookup;
 }
 
 const CLIENT_ID_STORAGE_KEY = "gloomberb.sync.clientId";
@@ -357,6 +360,7 @@ export class CloudSyncController {
         state: runtime.getState(),
         baselinePayload: this.loadBaseline(runtime)?.[entry.contributor.id] ?? null,
         memo: this.memoFor(runtime, entry.contributor.id),
+        isLocalMarketData: runtime.isLocalMarketData,
       });
       payloads[entry.contributor.id] = {
         schemaVersion: entry.contributor.schemaVersion,

package/src/sync/core-contributors.ts

@@ -1,4 +1,5 @@
 import { scheduleConfigSave } from "../state/config-save-scheduler";
+import { normalizeStoredBaseCurrency } from "../utils/base-currency";
 import { debugLog } from "../utils/debug-log";
 import { fnv1aHex, stableStringify } from "../utils/hash";
 import type { AppConfig, BrokerInstanceConfig, SavedLayout } from "../types/config";
@@ -39,6 +40,16 @@ import {
   knownBrokerHoldings,
   type KnownBrokerHoldings,
 } from "../brokers/broker-portfolio-sync";
+import {
+  isLocalOnlyInstance,
+  isLocalOnlyPortfolio,
+  localOnlyScope,
+  publicConfig,
+  publicMarketData,
+  publicTickers,
+  withLocalOnlyEntries,
+  type LocalOnlyScope,
+} from "./local-only";
 
 /**
  * What a saved layout mirrors from the live session rather than from the
@@ -612,9 +623,11 @@ function collectCoreCollectionsPayload(
   financials: Map<string, TickerFinancials>,
   exchangeRates: Map<string, number>,
   brokerAccounts: Record<string, BrokerAccount[]>,
+  /** The financials whose quotes may be uploaded: without those a source that keeps its market data local supplied. */
+  quoted: Map<string, TickerFinancials> = financials,
 ) {
   const records = [...tickers.values()]
-    .map((ticker) => sanitizeTickerMetadata(ticker.metadata, financials.get(ticker.metadata.ticker)))
+    .map((ticker) => sanitizeTickerMetadata(ticker.metadata, quoted.get(ticker.metadata.ticker)))
     .filter(isSyncableTicker);
 
   // Only the USD anchor goes on the wire, as before: readers of the snapshot
@@ -873,14 +886,38 @@ interface LayoutMergeContext {
   pushedAt?: string;
 }
 
+/** A pulled config without profiles and portfolios that are local-only here (an older build may have pushed them). */
+function publicConfigPayload(payload: Record<string, unknown>, scope: LocalOnlyScope): Record<string, unknown> {
+  const without = (entries: unknown, isLocal: (entry: Record<string, unknown>) => boolean) => (
+    Array.isArray(entries) ? entries.filter((entry) => !isRecord(entry) || !isLocal(entry)) : entries
+  );
+  return {
+    ...payload,
+    ...("brokerInstances" in payload ? { brokerInstances: without(payload.brokerInstances, (entry) => isLocalOnlyInstance({ id: String(entry.id) }, scope)) } : {}),
+    ...("portfolios" in payload ? { portfolios: without(payload.portfolios, (entry) => isLocalOnlyPortfolio(entry as unknown as Portfolio, scope)) } : {}),
+  };
+}
+
 function mergeConfigPayload(
   config: AppConfig,
   payload: unknown,
   baselineConfig: AppConfig = config,
   lastSyncedPayload?: unknown,
   layoutContext: LayoutMergeContext = {},
+  scope: LocalOnlyScope | null = null,
 ): AppConfig | null {
   if (!isRecord(payload)) return null;
+  if (scope) {
+    // Merged as if the local-only profiles and portfolios were not here, then put back as they were.
+    const local = publicConfig(config, scope);
+    const merged = mergeConfigPayload(local, publicConfigPayload(payload, scope), baselineConfig === config ? local : publicConfig(baselineConfig, scope),
+      lastSyncedPayload, layoutContext);
+    return merged && {
+      ...merged,
+      brokerInstances: withLocalOnlyEntries(merged.brokerInstances, config.brokerInstances, (instance) => isLocalOnlyInstance(instance, scope)),
+      portfolios: withLocalOnlyEntries(merged.portfolios, config.portfolios, (portfolio) => isLocalOnlyPortfolio(portfolio, scope)),
+    };
+  }
   const next: AppConfig = { ...config };
   // Two guards, both needed. baselineConfig catches edits made while this pull
   // was in flight; lastSyncedPayload catches edits made while the app was not
@@ -900,6 +937,8 @@ function mergeConfigPayload(
   };
 
   assign("baseCurrency");
+  // A device on an older version may still send a name or sign (Canadian dollar, CA$): it applies as its code, as a saved one loads.
+  if (typeof next.baseCurrency === "string" && next.baseCurrency.trim()) next.baseCurrency = normalizeStoredBaseCurrency(next.baseCurrency);
   assign("refreshIntervalMinutes");
   if ("portfolios" in payload && canApply("portfolios")) {
     const syncedPortfolios = payload.portfolios;
@@ -1148,6 +1187,8 @@ interface PulledTickersMerge {
   /** This device's live broker portfolios, each with the side holding its latest broker sync. */
   brokerPortfolios: ReadonlyMap<string, "local" | "pulled">;
   known: KnownBrokerHoldings;
+  /** Connections kept on this device: their portfolios' holdings here outlast any pull. */
+  localOnly: LocalOnlyScope | null;
 }
 
 /**
@@ -1224,7 +1265,7 @@ function mergePulledTicker(
   const portfolios: string[] = [];
   for (const portfolioId of portfolioIds) {
     const brokerSide = merge.brokerPortfolios.get(portfolioId);
-    const takePulled = brokerSide
+    const takePulled = merge.localOnly?.portfolioIds.has(portfolioId) ? false : brokerSide
       ? brokerSide === "pulled"
       : !comparable || sameAsStored(
         holdingIn(localPositions, localLinks, portfolioId),
@@ -1269,7 +1310,7 @@ export const coreConfigSyncContributor: SyncContributor = {
   id: CORE_CONFIG_CONTRIBUTOR_ID,
   schemaVersion: 1,
   collect: ({ state, baselinePayload, memo }) => withLayoutProvenance(
-    collectCoreConfigPayload(state.config) as Record<string, unknown>,
+    collectCoreConfigPayload(publicConfig(state.config, localOnlyScope(state.config))) as Record<string, unknown>,
     baselinePayload,
     memo?.get(),
   ),
@@ -1282,7 +1323,7 @@ export const coreConfigSyncContributor: SyncContributor = {
     const nextConfig = mergeConfigPayload(state.config, payload, baselineState.config, baselinePayload, {
       memo: memo?.get(),
       pushedAt,
-    });
+    }, localOnlyScope(state.config));
     if (!nextConfig) return;
     const configChanged = !valuesEqual(nextConfig, state.config);
     if (configChanged) {
@@ -1328,15 +1369,24 @@ export const coreConfigSyncContributor: SyncContributor = {
 export const coreCollectionsSyncContributor: SyncContributor = {
   id: "core.collections",
   schemaVersion: 1,
-  collect: async ({ state }) => collectCoreCollectionsPayload(
-    state.config,
-    state.tickers,
-    state.financials,
-    await loadHoldingExchangeRates(state.config, state.tickers, state.financials),
-    state.brokerAccounts,
-  ),
+  collect: async ({ state, isLocalMarketData }) => {
+    // Connections the user keeps on this device stay here, with their portfolios, account values and
+    // positions; so do the quotes and bars of a source that keeps its market data local.
+    const scope = localOnlyScope(state.config);
+    const config = publicConfig(state.config, scope);
+    const tickers = publicTickers(state.tickers, scope);
+    return collectCoreCollectionsPayload(
+      config,
+      tickers,
+      state.financials,
+      await loadHoldingExchangeRates(config, tickers, state.financials),
+      state.brokerAccounts,
+      publicMarketData(state.financials, isLocalMarketData),
+    );
+  },
   apply: async (payload, { snapshot, baselinePayload, baselineState, getState, isCurrent, dispatch, tickerRepository }) => {
     if (!isRecord(payload)) return;
+    const scope = localOnlyScope(getState().config);
     hydrateProfileAnalytics(payload);
     if (!isCurrent()) return;
     // The config contributor applies first, so this is the config this pull left.
@@ -1356,6 +1406,7 @@ export const coreCollectionsSyncContributor: SyncContributor = {
         portfolios: [pulledPortfolios, pulledConfig?.portfolios].flatMap(idEntries),
         brokerInstances: idEntries(pulledConfig?.brokerInstances),
       }),
+      localOnly: scope,
     };
     // Tickers here and pulled ones drop the ids of any watchlist that is gone
     // (removed elsewhere, or deleted by an older build that left its id on the

package/src/sync/local-only.ts

@@ -0,0 +1,121 @@
+import type { AppConfig, BrokerInstanceConfig } from "../types/config";
+import type { Quote, TickerFinancials } from "../types/financials";
+import type { BrokerContractRef } from "../types/instrument";
+import type { Portfolio, TickerPosition, TickerRecord } from "../types/ticker";
+
+/**
+ * Broker connections the user keeps on this device (`BrokerInstanceConfig.localOnly`), and the
+ * portfolios of their accounts. Cloud sync leaves the connections, those portfolios with their
+ * account values, and the positions held in them out of every push, and keeps them through every
+ * pull, so nothing of them reaches Gloom Cloud and a pull never removes them here.
+ */
+export interface LocalOnlyScope {
+  instanceIds: ReadonlySet<string>;
+  portfolioIds: ReadonlySet<string>;
+}
+
+/**
+ * Whether a source keeps the quotes and bars it supplies on this device (`BrokerAdapter.localMarketData`),
+ * by its provider id: a broker's is its broker id.
+ */
+export type LocalMarketDataLookup = (providerId: string) => boolean;
+
+/** The connections the user keeps on this device, or null when there are none. */
+export function localOnlyScope(config: Pick<AppConfig, "brokerInstances" | "portfolios">): LocalOnlyScope | null {
+  const instanceIds = new Set(config.brokerInstances.flatMap((instance) => instance.localOnly === true ? [instance.id] : []));
+  if (instanceIds.size === 0) return null;
+  const scope = { instanceIds, portfolioIds: new Set<string>() };
+  return { instanceIds, portfolioIds: new Set(config.portfolios.flatMap((portfolio) => isLocalOnlyPortfolio(portfolio, scope) ? [portfolio.id] : [])) };
+}
+
+export function isLocalOnlyInstance(instance: Pick<BrokerInstanceConfig, "id">, scope: LocalOnlyScope): boolean {
+  return scope.instanceIds.has(instance.id);
+}
+
+export function isLocalOnlyPortfolio(portfolio: Pick<Portfolio, "id" | "brokerInstanceId">, scope: LocalOnlyScope): boolean {
+  return scope.portfolioIds.has(portfolio.id) || !!portfolio.brokerInstanceId && scope.instanceIds.has(portfolio.brokerInstanceId)
+    // A pulled portfolio has no profile id; its own id names the profile.
+    || [...scope.instanceIds].some((id) => portfolio.id.startsWith(`broker:${id}:`));
+}
+
+function isLocalOnlyPosition(position: Pick<TickerPosition, "portfolio" | "brokerInstanceId">, scope: LocalOnlyScope): boolean {
+  return scope.portfolioIds.has(position.portfolio) || !!position.brokerInstanceId && scope.instanceIds.has(position.brokerInstanceId);
+}
+
+function isLocalOnlyContract(contract: Pick<BrokerContractRef, "brokerInstanceId">, scope: LocalOnlyScope): boolean {
+  return !!contract.brokerInstanceId && scope.instanceIds.has(contract.brokerInstanceId);
+}
+
+/** The config as Cloud sync may see it: without the connections kept on this device and their portfolios. */
+export function publicConfig<T extends Pick<AppConfig, "brokerInstances" | "portfolios">>(config: T, scope: LocalOnlyScope | null): T {
+  if (!scope) return config;
+  const brokerInstances = config.brokerInstances.filter((instance) => !isLocalOnlyInstance(instance, scope));
+  const portfolios = config.portfolios.filter((portfolio) => !isLocalOnlyPortfolio(portfolio, scope));
+  if (brokerInstances.length === config.brokerInstances.length && portfolios.length === config.portfolios.length) return config;
+  return { ...config, brokerInstances, portfolios };
+}
+
+/** The ticker as Cloud sync may see it: without positions, portfolios or contracts of connections kept on this device. */
+function publicTicker(ticker: TickerRecord, scope: LocalOnlyScope | null): TickerRecord {
+  if (!scope) return ticker;
+  const { metadata } = ticker;
+  const positions = metadata.positions.filter((position) => !isLocalOnlyPosition(position, scope));
+  const portfolios = metadata.portfolios.filter((id) => !scope.portfolioIds.has(id));
+  const contracts = metadata.broker_contracts?.filter((contract) => !isLocalOnlyContract(contract, scope));
+  if (positions.length === metadata.positions.length && portfolios.length === metadata.portfolios.length
+    && contracts?.length === metadata.broker_contracts?.length) return ticker;
+  return { ...ticker, metadata: { ...metadata, positions, portfolios, ...(contracts ? { broker_contracts: contracts } : {}) } };
+}
+
+export function publicTickers(tickers: Map<string, TickerRecord>, scope: LocalOnlyScope | null): Map<string, TickerRecord> {
+  if (!scope) return tickers;
+  return new Map([...tickers].map(([symbol, ticker]) => [symbol, publicTicker(ticker, scope)]));
+}
+
+/** The quote fields sync uploads, any of which a source that keeps its market data local may have supplied. */
+const SYNCED_QUOTE_FIELDS = ["price", "change", "changePercent", "previousClose"] as const;
+
+function isLocalQuote(quote: Quote, isLocal: LocalMarketDataLookup): boolean {
+  const provenance = quote.provenance;
+  const providers = [quote.providerId, provenance?.price?.providerId, ...SYNCED_QUOTE_FIELDS.map((field) => provenance?.fields?.[field]?.providerId)];
+  return providers.some((providerId) => !!providerId && isLocal(providerId));
+}
+
+/** The provider of stored bars, from their source key: `provider:<id>` or `broker:<broker id>:<profile>`. */
+function historyProvider(sourceKey: string | undefined): string | null {
+  const [kind, id] = sourceKey?.split(":") ?? [];
+  return (kind === "provider" || kind === "broker") && id ? id : null;
+}
+
+/**
+ * Financials as Cloud sync may upload them: without a quote or bars a source that keeps its market
+ * data local supplied. Sync reads only the quote and the week's move from them.
+ */
+export function publicMarketData(financials: Map<string, TickerFinancials>, isLocal?: LocalMarketDataLookup): Map<string, TickerFinancials> {
+  if (!isLocal) return financials;
+  const output = new Map<string, TickerFinancials>();
+  for (const [symbol, entry] of financials) {
+    const localQuote = !!entry.quote && isLocalQuote(entry.quote, isLocal);
+    const provider = historyProvider(entry.priceHistorySourceKey);
+    const localBars = !!provider && isLocal(provider);
+    output.set(symbol, localQuote || localBars ? { ...entry, ...(localQuote ? { quote: undefined } : {}), ...(localBars ? { priceHistory: [] } : {}) } : entry);
+  }
+  return output;
+}
+
+/**
+ * `merged` (a list merged without the local-only entries) with this device's local-only entries
+ * of `local` back where they were: each stays at its place among the others, so an unchanged list
+ * comes back equal to `local`. An entry the pull brought that is local-only here is left out.
+ */
+export function withLocalOnlyEntries<T>(merged: readonly T[], local: readonly T[], isLocalOnly: (entry: T) => boolean): T[] {
+  const incoming = merged.filter((entry) => !isLocalOnly(entry));
+  const output: T[] = [];
+  let next = 0;
+  for (const entry of local) {
+    if (isLocalOnly(entry)) output.push(entry);
+    else if (next < incoming.length) output.push(incoming[next++]!);
+  }
+  output.push(...incoming.slice(next));
+  return output;
+}

package/src/sync/react.ts

@@ -41,6 +41,12 @@ export function useCloudSyncRuntime({
       baselineStore,
       getContributors: () => pluginRegistry.getEnabledSyncContributors(),
       getTransport: () => pluginRegistry.getActiveSyncTransport(),
+      isLocalMarketData: (providerId) => {
+        const broker = pluginRegistry.brokers.get(providerId);
+        if (broker) return broker.localMarketData === true;
+        // A broker whose plugin is off may still have its quotes about from before; they stay here too.
+        return getState().config.brokerInstances.some((instance) => instance.brokerType === providerId);
+      },
     });
   }, [baselineStore, dispatch, getState, pluginRegistry, tickerRepository]);