gloomberb 0.18.0 → 0.18.2

package/src/renderers/dom/desktop/select-field.tsx

@@ -38,6 +38,7 @@ export function WebSelectField({
   const [open, setOpen] = useState(false);
   const buttonRef = useRef<HTMLButtonElement | null>(null);
   const inline = variant === "inline";
+  const well = variant === "well";
   const current = options.find((option) => option.value === value);
   const showUnset = includeUnsetOption && !current;
 
@@ -54,9 +55,9 @@ export function WebSelectField({
   setSelectRef.current = selectRef;
 
   const resolvedWidth = width ?? (inline ? "auto" : 184);
-  // A field is one row inside its border, as a text field is; inline it is the row.
+  // A field is one row inside its border, as a text field is; inline it is the row, and a well has no border.
   const row = WEB_CELL_HEIGHT;
-  const resolvedHeight = height ?? (inline ? row : row + 2);
+  const resolvedHeight = height ?? (inline || well ? row : row + 2);
   const style: CSSProperties = {
     width: resolvedWidth,
     height: resolvedHeight,
@@ -65,10 +66,11 @@ export function WebSelectField({
     justifyContent: "space-between",
     gap: "var(--gloom-space-xs)",
     color: disabled ? colors.textMuted : colors.text,
-    // The field look: sunk into the surface, the control border, the accent while open.
-    backgroundColor: inline ? "transparent" : "var(--gloom-surface-sunken)",
-    border: inline ? "none" : `1px solid ${open ? "var(--gloom-accent)" : "var(--gloom-control-border)"}`,
-    borderRadius: inline ? 0 : "var(--gloom-radius-md)",
+    // The field look: sunk into the surface, the control border, the accent while open. A well is the panel's
+    // fill with no border, for a dense form such as the order ticket.
+    backgroundColor: inline ? "transparent" : well ? "var(--gloom-panel)" : "var(--gloom-surface-sunken)",
+    border: inline || well ? "none" : `1px solid ${open ? "var(--gloom-accent)" : "var(--gloom-control-border)"}`,
+    borderRadius: inline ? 0 : well ? "var(--gloom-radius-sm)" : "var(--gloom-radius-md)",
     padding: inline ? 0 : "0 var(--gloom-space-sm)",
     cursor: disabled ? "default" : "pointer",
     font: "inherit",

package/src/renderers/dom/host/style.ts

@@ -18,6 +18,7 @@ function cellInset(value: unknown, axis: "x" | "y"): CSSProperties["paddingLeft"
 }
 
 export function commonStyle(props: Record<string, unknown>): CSSProperties {
+  const border = props.border;
   const hasFixedInlineSize = props.width != null || props.flexBasis != null;
   const hasFixedBlockSize = props.height != null;
   const gapUnit = props.flexDirection === "row" ? WEB_CELL_WIDTH : WEB_CELL_HEIGHT;
@@ -60,7 +61,11 @@ export function commonStyle(props: Record<string, unknown>): CSSProperties {
     ...(props.columnGap != null ? { columnGap: cellWidth(props.columnGap) as CSSProperties["columnGap"] } : {}),
     ...(props.rowGap != null ? { rowGap: cellHeight(props.rowGap) as CSSProperties["rowGap"] } : {}),
     overflow: props.overflow as CSSProperties["overflow"],
-    border: props.border ? `1px solid ${typeof props.borderColor === "string" ? props.borderColor : "var(--gloom-border)"}` : undefined,
+    // A requested divider or accent is not a frame. Use longhands consistently
+    // so switching between one edge, all edges and no border clears stale sides.
+    borderStyle: props.border ? "solid" : undefined,
+    borderColor: props.border ? typeof props.borderColor === "string" ? props.borderColor : "var(--gloom-border)" : undefined,
+    borderWidth: Array.isArray(border) ? ["top", "right", "bottom", "left"].map(side => border.includes(side) ? "1px" : "0px").join(" ") : border ? "1px" : undefined,
     boxSizing: "border-box",
     minInlineSize: zeroMinInlineSize ? 0 : undefined,
     minBlockSize: zeroMinBlockSize ? 0 : undefined,

package/src/renderers/dom/host/tabs.tsx

@@ -258,6 +258,11 @@ export function WebTabs({
               tab.onContextMenu?.(tab.value, event);
             } : undefined}
           >
+            {tab.leading !== undefined && (
+              <span data-gloom-role="tab-leading" aria-hidden="true" style={{ display: "flex", flex: "none", alignItems: "center" }}>
+                {tab.leading}
+              </span>
+            )}
             <span
               data-gloom-role="tab-label"
               style={{
@@ -349,6 +354,7 @@ export function WebTabs({
               items={tabs.map((tab) => ({
                 id: tab.value,
                 label: tab.label,
+                leading: tab.leading,
                 disabled: tab.disabled,
                 selected: tab.value === activeValue,
               }))}

package/src/renderers/dom/styles.css

@@ -70,6 +70,10 @@ button, [data-gloom-interactive="true"] { cursor: pointer; }
 [data-gloom-role="desktop-button"]:is([data-gloom-variant="plain"], [data-gloom-variant="ghost"], [data-gloom-variant="secondary"]):not(:disabled):not([aria-pressed="true"]):hover {
   background-color: var(--gloom-hover-fill);
 }
+/* Quiet quick actions take the same wash, over a chosen one's fill too. */
+[data-gloom-role="desktop-button"][data-gloom-variant="quiet"]:not(:disabled):hover {
+  background-color: var(--gloom-hover-fill) !important;
+}
 [data-gloom-hover-bg="true"]:hover {
   background-color: var(--gloom-box-hover-bg) !important;
 }
@@ -941,12 +945,14 @@ html[data-gloom-screenshot="true"] [data-gloom-role="chart-watermark"] {
 }
 .gloom-qb-inline .gloom-qb-view { margin-left: 0; box-shadow: none; align-self: stretch; }
 /* A long inline choice (an expiry strip) scrolls by itself, as the terminal's
-   does, so its label and the controls beside it stay in view. */
+   does, so its label and the controls beside it stay in view. It narrows with
+   its group and has no floor of its own: a floor wider than the room the bar
+   gives it drew its next choice under the control beside it. */
 .gloom-qb-filters[data-strip="true"],
 .gloom-qb-inline[data-strip="true"] { flex: 0 1 auto; min-width: 0; }
 .gloom-qb-inline[data-strip="true"] .gloom-qb-segments {
   flex: 0 1 auto;
-  min-width: 12ch;
+  min-width: 0;
   overflow-x: auto;
   scrollbar-width: none;
 }
@@ -1354,8 +1360,9 @@ html[data-gloom-screenshot="true"] [data-gloom-role="chart-watermark"] {
   white-space: nowrap;
 }
 
-/* Icon-only button: pane header, footer, dialog close, window controls. */
-.gloom-icon-button {
+/* Icon-only button: pane header, footer, dialog close, window controls. A
+   footer status icon (a delayed source's clock) takes the same box. */
+.gloom-icon-button, [data-gloom-role="pane-footer-icon"] {
   flex: none;
   display: inline-flex;
   align-items: center;
@@ -1372,7 +1379,7 @@ html[data-gloom-screenshot="true"] [data-gloom-role="chart-watermark"] {
   cursor: pointer;
   transition: background-color 120ms ease, color 120ms ease;
 }
-.gloom-icon-button:disabled { cursor: default; }
+.gloom-icon-button:disabled, [data-gloom-role="pane-footer-icon"] { cursor: default; }
 .gloom-icon-button:not(:disabled):hover { background: var(--gloom-hover-fill); color: var(--gloom-text-bright); }
 .gloom-icon-button[aria-pressed="true"] { color: var(--gloom-warning); }
 .gloom-qb-view button:disabled { color: var(--gloom-text-muted); opacity: 0.55; cursor: default; }

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

@@ -30,6 +30,7 @@ const BROKER_INVOKE_OPERATIONS = new Set([
   "getChartResolutionCapabilities",
   "getOptionsChain",
   "listOpenOrders",
+  "getOrderStatus",
   "listExecutions",
   "previewOrder",
   "placeOrder",
@@ -116,6 +117,8 @@ function invokeBrokerOperation(
     case "previewOrder":
     case "placeOrder":
       return (broker[operation] as any)?.call(broker, instance, args[0]);
+    case "getOrderStatus":
+      return broker.getOrderStatus?.(instance, args[0] as number);
     case "modifyOrder":
       return broker.modifyOrder?.(instance, args[0] as number, args[1] as never);
     case "cancelOrder":
@@ -167,6 +170,15 @@ function createBrokerCapability(options: CoreCapabilityOptions): PluginCapabilit
           },
         );
       }),
+      orders: stream((input: any, emit) => {
+        const instanceId = requireString(input.instanceId, "Broker instance");
+        const { instance, broker } = resolveBrokerInstance(options, instanceId);
+        if (!broker.subscribeOrders) throw new Error(`Broker "${broker.name}" does not stream orders.`);
+        return broker.subscribeOrders(instance, {
+          order: (order) => emit({ kind: "order", order }),
+          live: (live) => emit({ kind: "orders-live", live }),
+        });
+      }),
       removeInstance: op(async (input: any) => {
         const { instance, broker } = resolveBrokerInstance(options, input.instanceId);
         await broker.disconnect?.(instance);

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

@@ -14,6 +14,7 @@ import {
   loadExternalPlugin,
 } from "../../../plugins/loader";
 import { createNodePluginManager } from "../../../plugins/manager-node";
+import { readPluginIcon } from "../../../plugins/plugin-icon";
 import type { PluginRegistry } from "../../../plugins/registry";
 import { desktopRendererCapabilityManifests } from "./desktop/initialization";
 import { reportCrash } from "../../../telemetry/crash-reports";
@@ -70,6 +71,7 @@ async function bundlePluginDirectory(
 
   const { plugin } = loaded;
   const directory = basename(pluginDir);
+  const icon = readPluginIcon(pluginDir);
   const base = {
     id: plugin.id,
     name: plugin.name,
@@ -80,6 +82,7 @@ async function bundlePluginDirectory(
     ...(loaded.commit ? { commit: loaded.commit } : {}),
     ...(loaded.repo ? { repo: loaded.repo } : {}),
     ...(loaded.linked ? { linked: true } : {}),
+    ...(icon ? { icon } : {}),
     ...(plugin.targets ? { targets: plugin.targets } : {}),
   };
 

package/src/renderers/electrobun/shared/protocol.ts

@@ -130,6 +130,8 @@ export interface DesktopExternalPluginBundle {
   /** `owner/repo` of the checkout's GitHub origin. */
   repo?: string;
   linked?: boolean;
+  /** The plugin's logo as a `data:` URL, read from the checkout by the Bun process. */
+  icon?: string;
   /** ES module source, absent when `error` or `unsupportedTarget` is set. */
   code?: string;
   targets?: readonly ("cli" | "tui" | "desktop" | "web")[];

package/src/renderers/electrobun/view/broker-remote-client.ts

@@ -125,6 +125,22 @@ const client: BrokerRemoteClient = {
     });
   },
 
+  subscribeOrders(instanceId, listener) {
+    return subscribeBackendCapability({
+      subscriptionId: `broker-orders:${instanceId}:${nextSubscriptionId++}`,
+      capabilityId: BROKER_CAPABILITY_ID,
+      operationId: "orders",
+      payload: { instanceId },
+      onEvent: (message) => {
+        const event = message as BrokerRemoteEvent;
+        if (event.kind === "order") listener.order(event.order);
+        else if (event.kind === "orders-live") listener.live?.(event.live);
+      },
+      // A stream that cannot open leaves the host polling open orders.
+      onError: (error) => { listener.live?.(false); console.error("Failed to subscribe to broker orders", error); },
+    });
+  },
+
   async removeInstance(instanceId) {
     await invokeBrokerCapability("removeInstance", { instanceId });
     statuses.delete(instanceId);

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

@@ -28,6 +28,7 @@ export async function loadDesktopExternalPlugin(bundle: DesktopExternalPluginBun
     ...(bundle.commit ? { commit: bundle.commit } : {}),
     ...(bundle.repo ? { repo: bundle.repo } : {}),
     ...(bundle.linked ? { linked: true } : {}),
+    ...(bundle.icon ? { icon: bundle.icon } : {}),
   };
   const fallback = {
     ...base,

package/src/series/validate.ts

@@ -14,8 +14,8 @@ const DRAW_STYLES: readonly SeriesDrawStyle[] = ["line", "area", "step", "column
 const PLACEMENTS: readonly SeriesPlacement[] = ["price", "panel"];
 const LINE_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
 const COLOR_PATTERN = /^#[0-9A-Fa-f]{6}$/;
-/** A chart holds ten series: the ticker's price and the lines, with one to spare. */
-const MAX_SERIES_LINES = 8;
+/** A chart holds twenty series: the ticker's price and up to sixteen lines, with room for a few more. */
+const MAX_SERIES_LINES = 16;
 
 /** Units with no scale: a percentage of something, not a quantity of it. */
 const RATE_UNITS = ["%", "bp", "x", "ratio", "index", "score", "points"] as const;

package/src/sources/gloomberb-cloud/fred-series.ts

@@ -53,9 +53,34 @@ export function resetFredSeriesPersistence(): void {
   cache.reset();
 }
 
-/** The series' page on the FRED site, where its notes and release schedule live. */
+/** Who publishes a series Gloom Cloud serves in FRED's shape that FRED does not carry, and its page. */
+interface SeriesNotOnFred {
+  /** Who compiles the figures (TurkStat). */
+  publisher: string;
+  /** Whose publication they are read from (the CBRT). */
+  via: string;
+  url: string;
+}
+
+const TURKISH_CPI: SeriesNotOnFred = {
+  publisher: "TurkStat",
+  via: "the CBRT",
+  url: "https://www.tcmb.gov.tr/wps/wcm/connect/EN/TCMB+EN/Main+Menu/Statistics/Inflation+Data/Consumer+Prices",
+};
+
+const NOT_ON_FRED: Readonly<Record<string, SeriesNotOnFred>> = {
+  TURCPIYOY: TURKISH_CPI,
+  TURCPIMOM: TURKISH_CPI,
+};
+
+/** The publisher of a served series FRED does not carry; null for FRED's own. */
+export function seriesNotOnFred(seriesId: string): SeriesNotOnFred | null {
+  return NOT_ON_FRED[seriesId.trim().toUpperCase()] ?? null;
+}
+
+/** The series' page on the FRED site, where its notes and release schedule live, or its publisher's page when FRED does not carry it. */
 export function fredSeriesUrl(seriesId: string): string {
-  return `https://fred.stlouisfed.org/series/${seriesId}`;
+  return seriesNotOnFred(seriesId)?.url ?? `https://fred.stlouisfed.org/series/${seriesId}`;
 }
 
 function cacheKey(request: FredSeriesRequest): string {

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,