gloomberb 0.18.0 → 0.18.2

package/src/time-series/resolve.ts

@@ -1,6 +1,7 @@
 import { logFailure } from "../utils/log-failure";
 import { resolveAssetDisplayKind } from "../market-data/market/format";
 import { hasValidQuoteObservationTime } from "../market-data/quotes/freshness";
+import { delistingLabel } from "../market-data/quotes/delisting";
 import { SnapshotHistoryUnavailableError } from "../market-data/snapshot-provider";
 import { financialPeriodCoverage, financialPeriodCoverageWarnings, limitSeriesObservations } from "./financial-period-coverage";
 import { HistoryCoverageError, historyCoverageNotice } from "../sources/history-coverage";
@@ -10,6 +11,7 @@ import { getRouterEntityKey } from "../sources/provider-router/cache";
 import { publicListingTarget } from "../sources/listing-target";
 import { fetchHistoryResult } from "../sources/history-result";
 import type { HistorySession, PriceHistoryResult } from "../types/price-history";
+import type { BrokerContractRef } from "../types/instrument";
 import { FINANCIAL_VINTAGE_NOTICE, SEC_EPS_BASIS_NOTICE } from "../utils/financial-statements";
 import { appendLiveQuotePoint, hasUnknownBondHistoryBasis } from "./chart-data";
 import { LiveBarAccumulator } from "./live-bars";
@@ -63,7 +65,7 @@ import {
 } from "./studies";
 import { applyResolvedSeriesTransform } from "./transforms";
 import { clipSeriesToWindow } from "./alignment";
-import { clipPriceComparison, priceComparisonBoundsForSeries, priceComparisonSeriesIds, priceObservationWindowFilter, resolvePriceComparison, type PriceComparison } from "./price-comparison";
+import { bufferPriceComparison, clipPriceComparison, comparedBufferPoints, priceComparisonBoundsForSeries, priceComparisonSeriesIds, priceObservationWindowFilter, resolvePriceComparison, type PriceComparison } from "./price-comparison";
 import { reportingCurrencySeries } from "./reporting-currency";
 import { chartQuoteOverrideKeyForSource, compareChartQuoteRecency } from "./live-quotes";
 import { chartSeriesSourceKey } from "../capabilities/chart-series";
@@ -754,8 +756,8 @@ export function seedChartResolutionResult(
   const axisWarnings: string[] = [];
   const bufferedSeries = assignAxes([
     ...baseSeries,
-    ...applyStudyPresentationTransforms(studies.series, spec.studies, series, comparisonBounds, undefined, priceComparison),
-  ], [...spec.series, ...spec.studies], axisWarnings).map((entry) => clipPriceComparison(entry, priceComparison));
+    ...applyStudyPresentationTransforms(studies.series, spec.studies, series, comparisonBounds, undefined, priceComparison, bounds),
+  ], [...spec.series, ...spec.studies], axisWarnings).map((entry) => bufferPriceComparison(entry, priceComparison, bounds));
   const visible = bufferedSeries.map((entry) => {
     const entryBounds = presentationBounds(entry, spec.studies, priceComparison, bounds);
     const clipped = entryBounds.start !== null && entryBounds.end !== null
@@ -1168,6 +1170,17 @@ async function loadPriceHistory(
   return { ...result, expiresAt: retryAt ?? Date.now() + HISTORY_RETENTION_MAX_AGE_MS };
 }
 
+/**
+ * A US stock or fund listing, including one a broker contract routes through
+ * SMART in dollars. Options and futures have no pre-market session.
+ */
+function tradesUsExtendedHours(exchange: string | undefined, contract: BrokerContractRef | null | undefined): boolean {
+  if (contract?.secType && !["STK", "ETF"].includes(contract.secType.toUpperCase())) return false;
+  const venue = exchange || contract?.primaryExchange || contract?.exchange;
+  return isUsListingExchange(venue) || isUsListingExchange(contract?.primaryExchange)
+    || (!!contract && canonicalExchange(venue) === "SMART" && (!contract.currency || contract.currency.toUpperCase() === "USD"));
+}
+
 function baseSecuritySeries(
   spec: ChartSeriesSpec,
   financials: TickerFinancials,
@@ -1185,7 +1198,8 @@ function baseSecuritySeries(
   const symbol = instrumentLabel(spec.source);
   const statementCurrency = field.id.startsWith("fundamental.") && field.unit.startsWith("currency")
     ? reportingCurrencySeries(points, financials.financialCurrency) : null;
-  const currency = statementCurrency ? statementCurrency.currency : financials.quote?.currency || quoteMetadata?.currency;
+  // A broker contract names its currency even before (or without) a quote.
+  const currency = statementCurrency ? statementCurrency.currency : financials.quote?.currency || quoteMetadata?.currency || spec.source.instrument.instrument?.currency;
   const assetKind = resolveAssetDisplayKind({ assetCategory: financials.quote?.instrumentType || quoteMetadata?.instrumentType });
   const unknownBondBasis = hasUnknownBondHistoryBasis(financials.quote,
     spec.source.instrument.instrument?.secType, quoteMetadata?.instrumentType);
@@ -1220,10 +1234,25 @@ function baseSecuritySeries(
     || financials.quote?.listingExchangeName
     || financials.quote?.exchangeName;
   const marketField = isMarketFieldId(spec.source.fieldId);
+  // A routing code such as a broker's SMART names no venue. The quote's
+  // listing then supplies the session clock, so closed hours stay off the axis.
+  const sessionExchange = [marketExchange, financials.quote?.listingExchangeName, quoteMetadata?.listingExchangeName, financials.quote?.exchangeName]
+    .find((value) => resolveExchangeTimeZone(value));
+  // A dollar listing saved with IBKR's SMART route and no other venue trades on
+  // the US session, and so does a dollar option, which names no venue at all.
+  const dollars = !currency || currency === "USD";
+  const usOption = dollars && (spec.source.instrument.instrument?.secType?.toUpperCase() === "OPT"
+    || /^OPTION$/i.test(financials.quote?.instrumentType ?? quoteMetadata?.instrumentType ?? ""));
+  const routedUsListing = !sessionExchange && ((canonicalExchange(marketExchange) === "SMART" && dollars) || usOption);
   const marketTimeZone = marketField
     && canonicalExchange(marketExchange) !== "CCC"
-    ? resolveExchangeTimeZone(marketExchange)
+    ? resolveExchangeTimeZone(sessionExchange) ?? (routedUsListing ? "America/New_York" : null)
     : null;
+  // A route has no hours of its own: its sessions, which the day view and
+  // VWAP follow, are the venue's, and NYSE's for an unnamed dollar listing.
+  const listingExchange = canonicalExchange(marketExchange) === "SMART" || usOption
+    ? canonicalExchange(sessionExchange) || (routedUsListing ? "NYSE" : marketExchange)
+    : marketExchange;
   const latestChangePercent = marketField && field.unit.startsWith("currency")
     && !unknownBondBasis
     && financials.quote && hasValidQuoteObservationTime(financials.quote)
@@ -1259,12 +1288,12 @@ function baseSecuritySeries(
     panelId: spec.panelId,
     interpolation: spec.interpolation,
     observationKind: marketField ? "market" : undefined,
-    ...(marketField ? { listing: { symbol: spec.source.instrument.symbol, exchange: marketExchange ?? "" } } : {}),
+    ...(marketField ? { listing: { symbol: spec.source.instrument.symbol, exchange: listingExchange ?? "" } } : {}),
     timeBasis: marketTimeZone
       ? {
           kind: "market",
           timeZone: marketTimeZone,
-          exchange: canonicalExchange(marketExchange) || undefined,
+          exchange: canonicalExchange(sessionExchange) || undefined,
           cadenceMs: marketResolution
             ? CHART_RESOLUTION_STEP_MS[marketResolution]
             : undefined,
@@ -1487,6 +1516,7 @@ function applyStudyPresentationTransforms(
   visibleBounds: DateBounds,
   fallbackBaselineBounds?: DateBounds,
   priceComparison?: PriceComparison | null,
+  view: DateBounds = visibleBounds,
 ): ResolvedSeries[] {
   const rawById = new Map(rawSeries.map((series) => [series.id, series] as const));
   return outputs.map((output) => {
@@ -1502,7 +1532,7 @@ function applyStudyPresentationTransforms(
       : undefined;
     const transformed = applyResolvedSeriesTransform(output, input.transform, { baseline });
     const inputBounds = priceComparison?.sourceBounds?.[input.id];
-    return inputBounds ? { ...transformed, points: filterPoints(transformed.points, inputBounds) } : transformed;
+    return inputBounds ? { ...transformed, points: comparedBufferPoints(transformed.points, inputBounds, view) } : transformed;
   });
 }
 
@@ -1612,6 +1642,7 @@ async function resolveChartSpecPass(
     && entry.source.kind === "security" && isFundamentalFieldId(entry.source.fieldId))
     ? [FINANCIAL_VINTAGE_NOTICE] : [];
   const priorityWarnings: string[] = [];
+  const delistings = new Map<string, { symbol: string; label: string; notice: string }>();
   const baseSeriesIds = new Set(spec.series.map((entry) => entry.id));
   const visibleSeriesIds = new Set(spec.series
     .filter((entry) => entry.visible !== false)
@@ -1813,10 +1844,10 @@ async function resolveChartSpecPass(
   const hasExplicitWindow = explicitBounds(spec) !== null || movedWindow;
   const initialCalculationBounds = calculationBounds(spec, requestVisibleBounds, initialResolution);
 
-  // Only US listings trade before and after the regular session; asking elsewhere costs a request for nothing.
+  // Only US stocks and funds trade before and after the regular session; asking elsewhere costs a request for nothing.
   const extendedHoursFor = (source: Extract<ChartSeriesSpec["source"], { kind: "security" }>, resolution: ManualChartResolution) => (
     spec.viewport.extendedHours === true && isMarketFieldId(source.fieldId) && isIntradayResolution(resolution)
-      && !source.instrument.instrument && isUsListingExchange(source.instrument.exchange)
+      && tradesUsExtendedHours(source.instrument.exchange, source.instrument.instrument)
   );
   // A history starts after the visible window because its source keeps no more.
   let retainedHistoryOnly = false;
@@ -1952,6 +1983,14 @@ async function resolveChartSpecPass(
     const history = loaded.points;
     const coverageNotice = historyCoverageNotice(loaded.coverageStart, request.visibleBounds.start);
     if (coverageNotice) priorityWarnings.push(coverageNotice);
+    // A listing that no longer trades is named so beside its bars, which end on its last session.
+    if (loaded.delisting) {
+      const symbol = parsePublicTickerKey(source.instrument.symbol).symbol;
+      const label = delistingLabel(loaded.delisting);
+      const notice = `${symbol}: ${label}`;
+      priorityWarnings.push(notice);
+      if (!delistings.has(notice)) delistings.set(notice, { symbol, label, notice });
+    }
     // Read per request: one recovered window answers every visible window that shares its acquisition.
     if (loaded.recovery && request.visibleBounds.start !== null && request.visibleBounds.start < loaded.recovery.start) {
       priorityWarnings.push(historyRetentionNotice(loaded.recovery.retention, loaded.resolution ?? request.resolution,
@@ -2294,6 +2333,7 @@ async function resolveChartSpecPass(
         comparisonBounds,
         priceComparison ? undefined : requestVisibleBounds,
         priceComparison,
+        bounds,
       ),
     ];
     warnings.push(...studyResult.warnings);
@@ -2301,7 +2341,7 @@ async function resolveChartSpecPass(
   }
 
   const bufferedSeries = assignAxes(adoptPriceUnits(resolved, spec.series), [...spec.series, ...spec.studies], warnings)
-    .map((entry) => clipPriceComparison(entry, priceComparison));
+    .map((entry) => bufferPriceComparison(entry, priceComparison, bounds));
   resolved = bufferedSeries.map((entry) => {
     const entryBounds = presentationBounds(entry, spec.studies, priceComparison, bounds);
     return entryBounds.start !== null && entryBounds.end !== null
@@ -2388,6 +2428,7 @@ async function resolveChartSpecPass(
     loading: false,
     errors,
     warnings: [...new Set([...priorityWarnings, ...warnings])],
+    ...(delistings.size ? { delistings: [...delistings.values()] } : {}),
     viewport,
     resolution,
   };

package/src/time-series/spec.ts

@@ -85,7 +85,7 @@ export function coerceSeriesInterpolationForStyle(
   return style === "step" ? "step-after" : "none";
 }
 
-export const MAX_CHART_SERIES = 10;
+export const MAX_CHART_SERIES = 20;
 
 export const DEFAULT_CHART_SPEC: ChartSpec = Object.freeze({
   version: CHART_SPEC_VERSION,

package/src/time-series/types.ts

@@ -281,6 +281,11 @@ export interface ChartResolutionResult {
   loading: boolean;
   errors: string[];
   warnings: string[];
+  /**
+   * Each charted listing that no longer trades: its symbol and label
+   * ("Delisted Oct 27, 2022"), which `warnings` carries as "TWTR: Delisted Oct 27, 2022".
+   */
+  delistings?: { symbol: string; label: string; notice: string }[];
   /** Effective inclusive bounds used to clip the resolved chart data. */
   viewport?: { start: Date; end: Date };
   /** Bar resolution the loaded market history was fetched at. */

package/src/types/broker.ts

@@ -11,6 +11,7 @@ import type {
   BrokerOrderPreview,
   BrokerOrderRequest,
   BrokerPortfolioPerformance,
+  BrokerTradingCapabilities,
 } from "./trading";
 import type { CachePolicy, CachePolicyMap } from "./persistence";
 
@@ -85,10 +86,44 @@ export interface BrokerProfileAction {
   disabledReason?: string;
 }
 
+/** How a chart asks a broker for history beyond the regular session. */
+export interface BrokerHistoryOptions {
+  /** Include pre-market and after-hours bars. Only a broker that sets `extendedHoursHistory` is asked. */
+  session?: "extended";
+}
+
+/** What a broker's order stream calls. */
+export interface BrokerOrderListener {
+  /**
+   * An order as the broker now reports it: placed, partly or wholly filled,
+   * replaced, cancelled, rejected or expired. The same `orderId` names the
+   * order through all of them, as `getOrderStatus` and `cancelOrder` take it.
+   */
+  order(order: BrokerOrder): void;
+  /**
+   * Whether changes are being pushed now. While false, as before the first
+   * call, the host polls open orders instead; on true it reconciles once.
+   */
+  live?(live: boolean): void;
+}
+
 export interface BrokerAdapter {
   readonly id: string;
   readonly name: string;
   readonly cachePolicy?: CachePolicyMap;
+  /**
+   * Intraday history includes pre-market and after-hours bars when its
+   * `BrokerHistoryOptions` ask for the extended session. The chart then
+   * starts the day at the pre-market open; without it, the regular session.
+   */
+  readonly extendedHoursHistory?: boolean;
+  /**
+   * The quotes and bars this broker supplies stay on the user's device: Gloom Cloud sync never
+   * uploads them, for a broker whose terms restrict redistributing its market data. Its accounts
+   * sync like any broker's, unless the user keeps a connection on the device (`localOnly` on the
+   * profile). Hosts that honor it export `LOCAL_BROKER_MARKET_DATA` from `gloomberb/broker`.
+   */
+  readonly localMarketData?: boolean;
   validate(instance: BrokerInstanceConfig): Promise<boolean>;
   importPositions(instance: BrokerInstanceConfig): Promise<BrokerPosition[]>;
   importPortfolioSnapshot?(instance: BrokerInstanceConfig): Promise<{ accounts: BrokerAccount[]; positions: BrokerPosition[] }>;
@@ -116,9 +151,10 @@ export interface BrokerAdapter {
     bufferRange: TimeRange,
     resolution: ManualChartResolution,
     instrument?: BrokerContractRef | null,
+    options?: BrokerHistoryOptions,
   ): Promise<PricePoint[]>;
   /** Fetch higher-resolution price data for a specific date window (e.g. when zoomed in). */
-  getDetailedPriceHistory?(ticker: string, instance: BrokerInstanceConfig, exchange: string, startDate: Date, endDate: Date, barSize: string, instrument?: BrokerContractRef | null): Promise<PricePoint[]>;
+  getDetailedPriceHistory?(ticker: string, instance: BrokerInstanceConfig, exchange: string, startDate: Date, endDate: Date, barSize: string, instrument?: BrokerContractRef | null, options?: BrokerHistoryOptions): Promise<PricePoint[]>;
   getChartResolutionSupport?(
     ticker: string,
     instance: BrokerInstanceConfig,
@@ -136,6 +172,8 @@ export interface BrokerAdapter {
    * Whether this profile can stream quotes at all. Return false for modes that
    * only sync statements, so their positions stream from the cloud instead.
    * Quotes are also only routed to a broker whose status is "connected".
+   * Answer from the profile's configuration, not from session state: the
+   * desktop app asks in its view, while the session lives in the backend.
    */
   canStreamQuotes?(instance: BrokerInstanceConfig): boolean;
   subscribeQuotes?(
@@ -144,8 +182,25 @@ export interface BrokerAdapter {
     onQuote: (target: QuoteSubscriptionTarget, quote: Quote) => void,
   ): () => void;
   listOpenOrders?(instance: BrokerInstanceConfig): Promise<BrokerOrder[]>;
+  /**
+   * Pushes order changes as the broker reports them, for every account the
+   * profile includes. The host baselines from `listOpenOrders` and polls it
+   * while `live` is false or never called; see BrokerOrderListener.
+   */
+  subscribeOrders?(instance: BrokerInstanceConfig, listener: BrokerOrderListener): () => void;
+  /** Explicit status, including terminal orders. Null means unconfirmed, never cancelled by absence. */
+  getOrderStatus?(instance: BrokerInstanceConfig, orderId: number): Promise<BrokerOrder | null>;
   listExecutions?(instance: BrokerInstanceConfig): Promise<BrokerExecution[]>;
+  /** Opt into the shared ticket with supported combinations and current trading permission. */
+  getTradingCapabilities?(instance: BrokerInstanceConfig, contract?: BrokerContractRef, orderType?: BrokerOrderRequest["orderType"]): BrokerTradingCapabilities;
+  /** Config patch for the host's explicit enable/disable trading confirmation. Must not perform I/O. */
+  getTradingConfigUpdate?(instance: BrokerInstanceConfig, enabled: boolean): Record<string, unknown>;
   previewOrder?(instance: BrokerInstanceConfig, request: BrokerOrderRequest): Promise<BrokerOrderPreview>;
+  /**
+   * Place, change and cancel throw when the broker did not take the action. An error with `refused: true` says the
+   * broker answered no, or nothing was sent: the order is as it was, and its message is one short line the app shows as
+   * it is ("Aries cannot find this order"). Any other error is a lost answer, whose outcome the app treats as unknown.
+   */
   placeOrder?(instance: BrokerInstanceConfig, request: BrokerOrderRequest): Promise<BrokerOrder>;
   modifyOrder?(instance: BrokerInstanceConfig, orderId: number, request: BrokerOrderRequest): Promise<BrokerOrder>;
   cancelOrder?(instance: BrokerInstanceConfig, orderId: number): Promise<void>;

package/src/types/config.ts

@@ -18,6 +18,12 @@ export interface BrokerInstanceConfig {
   config: Record<string, unknown>;
   enabled?: boolean;
   lastSyncedAt?: number;
+  /**
+   * The user keeps this connection's data on this device: Cloud sync leaves out the profile, its
+   * accounts' portfolios and account values, and the positions in them. Daily roundups, the weekly
+   * brief, position alerts, the mobile app and Ask Gloom's portfolio context then go without it.
+   */
+  localOnly?: boolean;
 }
 
 export interface ColumnConfig {

package/src/types/data-provider.ts

@@ -119,7 +119,11 @@ export interface MarketDataRequestContext {
   brokerId?: string;
   brokerInstanceId?: string;
   instrument?: BrokerContractRef | null;
-  cacheMode?: "default" | "refresh";
+  /**
+   * "refresh" always fetches. "current" refetches a stored value past its stale time before answering, and
+   * answers with it only if that fetch fails: for a caller that cannot see a refresh landing in the background.
+   */
+  cacheMode?: "default" | "refresh" | "current";
   statementHistory?: "extended";
   /** A validated, same-target detailed retry constrained to one exhausted source. */
   historyRecovery?: import("../sources/history-retention").HistoryRecoveryCandidate;

package/src/types/financials.ts

@@ -34,6 +34,20 @@ export interface QuoteProvenance {
   rejectedPriceProviders?: string[];
 }
 
+/**
+ * A US listing that no longer trades, as Gloom Cloud states it: TWTR, last
+ * traded 2022-10-27 and removed from NYSE the next day. Its daily history is
+ * still served, ending on that session. Dates are New York trading dates.
+ */
+export interface ListingDelisting {
+  /** "delisted": the exchange's removal of the listing is on record; "inactive": only its last trade is known. */
+  status: "delisted" | "inactive";
+  /** The last session with a trade (YYYY-MM-DD). */
+  lastTradeDate: string;
+  /** The first session served (YYYY-MM-DD). */
+  historyStart: string;
+}
+
 /** Static listing facts from a quote observation, without an investable price. */
 export interface QuoteMetadataSource {
   providerId?: string;
@@ -81,6 +95,13 @@ export interface Quote extends DepositaryReceiptFacts {
   providerPriceDivisor?: number;
   change: number;
   changePercent: number;
+  /**
+   * What change and changePercent measure from when it is not previousClose,
+   * as Gloom Cloud says of a coin whose previous close it cannot date to the
+   * last two days: the last 24 hours ("24h", previousClose absent), or
+   * nothing ("none", no move). Absent on every other quote.
+   */
+  changeBasis?: "24h" | "none";
   previousClose?: number;
   /** Official close of a completed regular session, in this quote's currency. */
   regularClose?: number;
@@ -100,6 +121,8 @@ export interface Quote extends DepositaryReceiptFacts {
   receivedAt?: number; // local receipt timestamp ms for streamed/display freshness
   delivery?: QuoteDelivery;
   stale?: boolean;
+  /** The listing no longer trades: the price is its last trade (ListingDelisting). */
+  delisting?: ListingDelisting;
   exchangeName?: string;
   fullExchangeName?: string;
   listingExchangeName?: string;

package/src/types/headless.ts

@@ -103,6 +103,8 @@ export interface HeadlessPaneContext {
   /** Effective instance settings, after template creation and option normalization. */
   settings?: Record<string, unknown>;
   capabilities?: CapabilityInvoker;
+  /** Locally registered broker adapters. Reports may read account data; they never submit orders. */
+  resolveBroker?: (brokerType: string) => import("./broker").BrokerAdapter | null;
   /** Read one local portfolio without passing holdings through a remote endpoint. */
   resolvePortfolio?: (id: string) => Promise<{
     portfolio: import("./ticker").Portfolio;
@@ -131,6 +133,12 @@ export interface HeadlessPaneColumn {
   header: string;
   /** Print `header` as written, a field name such as `source`, where reports would otherwise title-case it. */
   literalHeader?: boolean;
+  /**
+   * What the text report heads the column with when it can say more than an
+   * export's header should (`Chg % UTC` over `Chg %`), printed as written;
+   * CSV keeps `header`, so a column read by its name stays where it was.
+   */
+  textHeader?: string;
   align?: "left" | "right" | "center";
   width?: number;
   /** False keeps the column whole when the text table is fitted to a narrow width, so a time or an id is never cut. */
@@ -229,9 +237,11 @@ export interface HeadlessPaneFreshness {
   /**
    * How often the data is published, when its dates mark the start of a period
    * (a monthly statistic is dated the 1st). The report then names the month,
-   * quarter or year, not a day it was never observed on.
+   * quarter or year, not a day it was never observed on. A semiannual estimate
+   * is dated by the month it was made in (USDA's coffee and sugar balances),
+   * so it names that month.
    */
-  periodicity?: "monthly" | "quarterly" | "annual";
+  periodicity?: "monthly" | "quarterly" | "semiannual" | "annual";
   /**
    * The newest row is a weekly or monthly bar whose period had not ended when
    * it was served (October's bar on 16 Oct), and the last day it covers so

package/src/types/instrument.ts

@@ -1,3 +1,5 @@
+import type { ListingDelisting } from "./financials";
+
 /**
  * What a ticker is, at the grain that decides which research has data for it:
  * filings, executives and analyst coverage exist for a company's stock,
@@ -77,4 +79,6 @@ export interface InstrumentSearchResult {
    * carries that name. A leftover listing of the merged company (GOGLC on
    * BYMA) is linked to it by search, naming the `successor`. */
   formerIssuer?: { symbol: string; name: string; until: string; successor?: { symbol: string; name: string | null } };
+  /** A US listing that no longer trades, found by its exact symbol (TWTR). Untrusted until parsed. */
+  delisting?: ListingDelisting;
 }

package/src/types/plugin.ts

@@ -1,6 +1,6 @@
 import type { ReactNode } from "react";
 import type { AppTickerRepositoryPort } from "../core/app-service-ports";
-import type { HeadlessPaneDefinition, HeadlessPaneFreshness, HeadlessPaneOptionDef } from "./headless";
+import type { HeadlessPaneContext, HeadlessPaneDefinition, HeadlessPaneFreshness, HeadlessPaneOptionDef } from "./headless";
 
 export type {
   HeadlessArgumentExpansion,
@@ -123,6 +123,12 @@ export interface PaneLock {
   token?: string;
   /** The session is signed in and its email is not verified yet. */
   verifyEmail?: boolean;
+  /**
+   * Reads data as the report does, so a note can check that a free route it
+   * would name has data for the symbol before naming it. Absent where nothing
+   * can be read.
+   */
+  context?: HeadlessPaneContext;
 }
 
 export interface PaneDef {
@@ -195,9 +201,10 @@ export interface PaneDef {
    * read without it and where, and how to unlock it. A `headless` pane's report
    * prints it when the server refuses the read (401, 402 or 403). Without it
    * the report prints the wall's own words, or the refusal. Either way it cites
-   * no source, since nothing was read.
+   * no source, since nothing was read. A free route it names must have data
+   * for the symbol (`lock.context` reads it), so the note may resolve later.
    */
-  reportLockNote?(lock: PaneLock): string;
+  reportLockNote?(lock: PaneLock): string | Promise<string>;
   /**
    * What a rendered-view report needs before it shows anything, such as a
    * sign-in: `gloomberb catalog` lists it under Requires, as it does a
@@ -880,8 +887,8 @@ export interface AppNotificationRequest {
   };
   /**
    * What a built-in notice is about, so the Unread list can keep it after the
-   * toast is gone and open it again: `price:<alertId>`, `catalyst:<eventId>`
-   * or `team:<cardId>`. Other values are not kept.
+   * toast is gone and open it again: `price:<alertId>`, `catalyst:<eventId>`,
+   * `econ:<eventId>` or `team:<cardId>`. Other values are not kept.
    */
   refId?: string;
   /** Rendered next to `action`. Use for a dismissing counterpart such as snooze. */
@@ -895,6 +902,13 @@ export interface BrokerInstanceUpdateOptions {
   label?: string;
   enabled?: boolean;
   replaceConfig?: boolean;
+  /** Keep this connection's data on this device, out of Gloom Cloud sync (`BrokerInstanceConfig.localOnly`). */
+  localOnly?: boolean;
+}
+
+export interface BrokerInstanceCreateOptions {
+  /** Keep the new connection's data on this device from the start, before its first import. */
+  localOnly?: boolean;
 }
 
 export interface PinTickerOptions {
@@ -906,6 +920,8 @@ export interface PinTickerOptions {
   listing?: TickerListingRef;
   /** Select this research tab once the requested ticker has resolved. */
   tabId?: string;
+  /** Merge this state into the resolved research pane when selecting `tabId`. */
+  tabState?: Record<string, unknown>;
 }
 
 export interface GloomPluginContext {
@@ -937,6 +953,8 @@ export interface GloomPluginContext {
   getData(ticker: string): TickerFinancials | null;
   getTicker(ticker: string): TickerRecord | null;
   getConfig(): import("./config").AppConfig;
+  /** Resolve a broker registered by another plugin, without connecting it. */
+  getBrokerAdapter?(brokerType: string): BrokerAdapter | null;
   getPaneDef(paneId: string): PaneDef | undefined;
 
   readonly marketData: DataProvider;
@@ -949,7 +967,7 @@ export interface GloomPluginContext {
   readonly paneSettings: PluginPaneSettingsState;
   readonly teamState: PluginTeamState;
 
-  createBrokerInstance(brokerType: string, label: string, values: Record<string, unknown>): Promise<BrokerInstanceConfig>;
+  createBrokerInstance(brokerType: string, label: string, values: Record<string, unknown>, options?: BrokerInstanceCreateOptions): Promise<BrokerInstanceConfig>;
   updateBrokerInstance(instanceId: string, values: Record<string, unknown>, options?: BrokerInstanceUpdateOptions): Promise<void>;
   syncBrokerInstance(instanceId: string): Promise<void>;
   removeBrokerInstance(instanceId: string): Promise<void>;

package/src/types/price-history.ts

@@ -1,5 +1,5 @@
 import type { ManualChartResolution } from "../time-series/resolution";
-import type { PricePoint } from "./financials";
+import type { ListingDelisting, PricePoint } from "./financials";
 
 /** Declared by the actual history source, independently of quote session state. */
 export interface HistorySession {
@@ -42,4 +42,9 @@ export interface PriceHistoryResult {
    * current copy, whatever its last bar, and for a source's own answer.
    */
   savedCopyBehind?: true;
+  /**
+   * The listing no longer trades: its bars end on `lastTradeDate` and no later
+   * session will add one, so a copy ending there is complete.
+   */
+  delisting?: ListingDelisting;
 }

package/src/types/ticker.ts

@@ -8,6 +8,15 @@ export interface TickerPosition {
   priceBasis?: PriceBasis;
   currency?: string;
   dateAcquired?: string;
+  /**
+   * What one unit of the lot's `currency` cost in `costFxCurrency` when it was
+   * bought: entered with the position, or the FX close of its purchase date.
+   * Valued in that currency, the lot's cost converts at this rate rather than
+   * today's, so its P&L carries the currency's move since.
+   */
+  costFxRate?: number;
+  /** The currency `costFxRate` converts the cost into: the portfolio's when it was entered. */
+  costFxCurrency?: string;
   broker: string; // "manual" | future broker plugin IDs
   side?: "long" | "short";
   marketValue?: number;