gloomberb 0.11.0 → 0.11.2

package/src/api-client/index.ts

@@ -3,11 +3,15 @@ import type { InstrumentSearchResult } from "../types/instrument";
 import { CloudAuthApi } from "./auth";
 import { CloudChatApi } from "./chat";
 import { CloudDataApi } from "./data";
+import { ApiRequestError } from "./errors";
 import { CloudApiRequestTransport } from "./request";
 import { CloudApiSocket } from "./socket";
 import type {
+  CloudCdsParams,
   CloudCongressHouseParams,
   CloudFredSeriesParams,
+  CloudSecFilingParams,
+  CloudSecFilingsParams,
   CloudHistoryParams,
   CloudNewsParams,
   CloudTickerTweetsParams,
@@ -40,10 +44,16 @@ import type {
   CloudCorporateActionsPayload,
   CloudPricePointPayload,
   CloudEconEventPayload,
+  CloudEquityDiagnosticMode,
+  CloudEquityDiagnosticResult,
+  CloudCdsResponse,
   CloudFredSeriesPayload,
   CloudYieldPointPayload,
   CloudCongressHousePayload,
   CloudNewsPayload,
+  CloudSecContentResponse,
+  CloudSecDocumentsResponse,
+  CloudSecFilingsResponse,
   CloudNewsListResponse,
   CloudTweetSearchResponse,
   CloudMarketResponse,
@@ -62,6 +72,13 @@ import type {
   ScannerKind,
 } from "./types";
 import type { SyncSettings, SyncSnapshot } from "../sync/types";
+import {
+  isMarketplaceLayoutId,
+  parseMarketplaceLayoutEntry,
+  parseMarketplaceLayoutList,
+  type LayoutMarketplaceEntry,
+  type LayoutMarketplacePayload,
+} from "../layout-marketplace/payload";
 
 export type * from "./types";
 export { setCloudApiFetchTransport } from "./request";
@@ -73,6 +90,8 @@ const ASSIST_REQUEST_TIMEOUT_MS = 6_000;
 
 class GloomApiClient {
   private currentUser: AuthUser | null = null;
+  private sessionChecked = false;
+  private sessionRequest: Promise<AuthUser | null> | null = null;
   private readonly currentUserListeners = new Set<() => void>();
   private readonly transport = new CloudApiRequestTransport();
   private readonly auth: CloudAuthApi;
@@ -84,6 +103,7 @@ class GloomApiClient {
     this.auth = new CloudAuthApi({
       getCurrentUser: () => this.currentUser,
       getSessionToken: () => this.transport.getSessionToken(),
+      hasSessionCredential: () => this.transport.hasSessionCredential(),
       request: (path, options) => this.request(path, options),
       requireCapturedSession: (message) => this.requireCapturedSession(message),
       setCurrentUser: (user) => this.setCurrentUser(user),
@@ -93,6 +113,7 @@ class GloomApiClient {
     this.socket = new CloudApiSocket({
       getBaseUrl: () => this.transport.baseUrl,
       getSocketAuthToken: () => this.getSocketAuthToken(),
+      hasSessionCredential: () => this.transport.hasSessionCredential(),
       hasVerifiedUser: () => this.currentUser?.emailVerified === true,
       isUsingWebSocketToken: () => !!this.transport.getWebSocketToken(),
       clearWebSocketTokenForFallback: () => this.transport.clearWebSocketTokenForFallback(),
@@ -123,8 +144,14 @@ class GloomApiClient {
     return this.transport.getWebSocketToken();
   }
 
+  setCookieSessionMode(enabled: boolean): void {
+    this.sessionChecked = false;
+    this.transport.setCookieSessionMode(enabled);
+  }
+
   setSessionToken(token: string | null): void {
     const changed = this.transport.getSessionToken() !== token;
+    this.sessionChecked = false;
     this.transport.setSessionToken(token);
     if (!token) {
       this.currentUser = null;
@@ -143,6 +170,15 @@ class GloomApiClient {
     return this.currentUser;
   }
 
+  /**
+   * Whether a signed-in session exists on this surface. Browser builds keep the
+   * session in an HttpOnly cookie, so the raw token is deliberately null there
+   * and the restored user is the only signal.
+   */
+  isSignedIn(): boolean {
+    return !!this.transport.getSessionToken() || !!this.currentUser;
+  }
+
   /** Notifies when the signed-in user changes, including plan and trial entitlement. */
   subscribeCurrentUser(listener: () => void): () => void {
     this.currentUserListeners.add(listener);
@@ -156,7 +192,7 @@ class GloomApiClient {
   }
 
   isVerified(): boolean {
-    return !!this.transport.getSessionToken() && !!this.currentUser?.emailVerified;
+    return this.transport.hasSessionCredential() && !!this.currentUser?.emailVerified;
   }
 
   private setCurrentUser(user: AuthUser | null): void {
@@ -187,7 +223,7 @@ class GloomApiClient {
   }
 
   private requireCapturedSession(message: string): void {
-    if (this.transport.getSessionToken()) return;
+    if (this.transport.hasSessionCredential()) return;
     this.transport.setWebSocketToken(null);
     this.setCurrentUser(null);
     throw new Error(message);
@@ -202,7 +238,9 @@ class GloomApiClient {
   }
 
   async ensureVerifiedSession(): Promise<AuthUser | null> {
-    return this.auth.ensureVerifiedSession();
+    if (!this.transport.hasSessionCredential()) return null;
+    if (!this.currentUser && !this.sessionChecked) await this.getSession();
+    return this.currentUser?.emailVerified ? this.currentUser : null;
   }
 
   async signUp(email: string, username: string, name: string, password: string): Promise<AuthUser> {
@@ -226,17 +264,47 @@ class GloomApiClient {
   }
 
   async getSession(): Promise<AuthUser | null> {
-    return this.auth.getSession();
+    if (this.sessionRequest) return this.sessionRequest;
+    this.sessionRequest = this.auth.getSession();
+    try {
+      const user = await this.sessionRequest;
+      this.sessionChecked = true;
+      return user;
+    } finally {
+      this.sessionRequest = null;
+    }
   }
 
   async sendVerification(): Promise<CloudVerificationResponse> {
     return this.auth.sendVerification();
   }
 
+  async requestPasswordReset(email: string): Promise<void> {
+    return this.auth.requestPasswordReset(email);
+  }
+
   async createBrowserHandoff(): Promise<CloudBrowserHandoffResponse> {
     return this.auth.createBrowserHandoff();
   }
 
+  /** Creates a Stripe checkout session for Cloud Pro; the URL opens in a browser. */
+  async createCloudCheckout(): Promise<{ url: string }> {
+    return this.request<{ url: string }>("/stripe/checkout", { method: "POST", body: JSON.stringify({}) });
+  }
+
+  /** Stores a verified user's public terminal snapshot or pane handoff. */
+  async createTerminalShare(payload: unknown): Promise<{ id: string; expiresAt: string }> {
+    return this.request<{ id: string; expiresAt: string }>("/shares", {
+      method: "POST",
+      body: JSON.stringify(payload),
+    });
+  }
+
+  /** Stripe billing portal for an account that already has a subscription. */
+  async createBillingPortal(): Promise<{ url: string }> {
+    return this.request<{ url: string }>("/stripe/portal", { method: "POST", body: JSON.stringify({}) });
+  }
+
   async getAccountProfile(): Promise<AccountProfile> {
     return this.auth.getAccountProfile();
   }
@@ -271,6 +339,45 @@ class GloomApiClient {
     });
   }
 
+  async getMarketplaceLayout(
+    id: string,
+    options?: { signal?: AbortSignal },
+  ): Promise<LayoutMarketplaceEntry | null> {
+    if (!isMarketplaceLayoutId(id)) return null;
+    try {
+      return parseMarketplaceLayoutEntry(await this.request<unknown>(`/layouts/${encodeURIComponent(id)}`, {
+        method: "GET",
+        signal: options?.signal,
+      }));
+    } catch (error) {
+      if (error instanceof ApiRequestError && error.status === 404) return null;
+      throw error;
+    }
+  }
+
+  async listMarketplaceLayouts(options?: { signal?: AbortSignal }): Promise<LayoutMarketplaceEntry[]> {
+    const items = parseMarketplaceLayoutList(await this.request<unknown>("/layouts", {
+      method: "GET",
+      signal: options?.signal,
+    }));
+    if (!items) throw new Error("The layout marketplace returned invalid data.");
+    return items;
+  }
+
+  async publishMarketplaceLayout(
+    name: string,
+    payload: LayoutMarketplacePayload,
+    options?: { signal?: AbortSignal },
+  ): Promise<LayoutMarketplaceEntry> {
+    const item = parseMarketplaceLayoutEntry(await this.request<unknown>("/layouts", {
+      method: "POST",
+      body: JSON.stringify({ name: name.trim(), ...payload }),
+      signal: options?.signal,
+    }));
+    if (!item) throw new Error("The layout marketplace returned invalid data.");
+    return item;
+  }
+
   async updateSyncSettings(update: Partial<SyncSettings>): Promise<SyncSettings> {
     const result = await this.request<{ settings: SyncSettings }>("/sync/settings", {
       method: "PATCH",
@@ -513,6 +620,14 @@ class GloomApiClient {
     return this.data.getCloudEconomicCalendar();
   }
 
+  async getCloudEquityDiagnostic(
+    symbol: string,
+    exchange?: string,
+    mode: CloudEquityDiagnosticMode = "cache-first",
+  ): Promise<CloudEquityDiagnosticResult> {
+    return this.data.getCloudEquityDiagnostic(symbol, exchange, mode);
+  }
+
   async getCloudFredSeries(
     seriesId: string,
     params: CloudFredSeriesParams = {},
@@ -524,10 +639,30 @@ class GloomApiClient {
     return this.data.getCloudYieldCurve();
   }
 
+  async getCloudCds(params: CloudCdsParams = {}): Promise<CloudCdsResponse> {
+    return this.data.getCloudCds(params);
+  }
+
   async getCloudCongressHouse(params: CloudCongressHouseParams = {}): Promise<CloudCongressHousePayload> {
     return this.data.getCloudCongressHouse(params);
   }
 
+  async getCloudSecFilings(params: CloudSecFilingsParams): Promise<CloudSecFilingsResponse> {
+    return this.data.getCloudSecFilings(params);
+  }
+
+  async getCloudSecFilingDocuments(params: CloudSecFilingParams): Promise<CloudSecDocumentsResponse> {
+    return this.data.getCloudSecFilingDocuments(params);
+  }
+
+  async getCloudSecFilingContent(params: CloudSecFilingParams): Promise<CloudSecContentResponse> {
+    return this.data.getCloudSecFilingContent(params);
+  }
+
+  async getCloudSec13F(path: string, params: Record<string, string | number | undefined> = {}): Promise<unknown> {
+    return this.data.getCloudSec13F(path, params);
+  }
+
   async getCloudNews(params: CloudNewsParams = {}): Promise<CloudNewsListResponse> {
     return this.data.getCloudNews(params);
   }

package/src/api-client/paths.ts

@@ -16,10 +16,19 @@ export type CloudFredSeriesParams = {
   sortOrder?: "asc" | "desc";
 };
 
+export type CloudCdsParams = {
+  /** Reference entity name, matched by the backend against DTCC issuer names. */
+  issuer?: string;
+  days?: number;
+  limit?: number;
+};
+
 export type CloudCongressHouseParams = {
   year?: number;
   limit?: number;
+  offset?: number;
   filingLimit?: number;
+  filingOffset?: number;
   member?: string;
   ticker?: string;
   refresh?: boolean;
@@ -60,6 +69,23 @@ export type CloudTweetSearchParams = {
   hours?: number;
 };
 
+const LOGO_SYMBOL_RE = /^[A-Z0-9][A-Z0-9._^:-]{0,23}$/;
+const CRYPTO_QUOTE = /[-/](USD|USDT|USDC|EUR|GBP|BTC)$/;
+
+export type CloudLogoKind = "ticker" | "crypto";
+
+export function normalizeCloudLogoSymbol(kind: CloudLogoKind, symbol: string): string | null {
+  let normalized = symbol.trim().toUpperCase();
+  if (kind === "crypto") normalized = normalized.replace(CRYPTO_QUOTE, "");
+  return LOGO_SYMBOL_RE.test(normalized) ? normalized : null;
+}
+
+export function cloudLogoPath(kind: CloudLogoKind, symbol: string): string | null {
+  const normalized = normalizeCloudLogoSymbol(kind, symbol);
+  if (!normalized) return null;
+  return `/cloud/logos/${kind}/${encodeURIComponent(normalized)}`;
+}
+
 function appendQuery(path: string, search: URLSearchParams): string {
   const query = search.toString();
   return `${path}${query ? `?${query}` : ""}`;
@@ -118,17 +144,80 @@ export function cloudFredSeriesPath(seriesId: string, params: CloudFredSeriesPar
   return appendQuery(`/cloud/econ/series/${encodeURIComponent(seriesId)}`, search);
 }
 
+export function cloudCdsPath(params: CloudCdsParams = {}): string {
+  const search = new URLSearchParams();
+  const issuer = params.issuer?.trim();
+  if (issuer) search.set("issuer", issuer);
+  if (params.days != null) search.set("days", String(params.days));
+  if (params.limit != null) search.set("limit", String(params.limit));
+  return appendQuery("/cloud/credit/cds", search);
+}
+
+export type CloudSecFilingsParams = {
+  ticker: string;
+  limit?: number;
+  offset?: number;
+};
+
+export type CloudSecFilingParams = {
+  cik?: string;
+  accession?: string;
+  form?: string;
+  primaryDocument?: string;
+  primaryDocumentUrl?: string;
+  filingUrl?: string;
+};
+
 export function cloudCongressHousePath(params: CloudCongressHouseParams = {}): string {
   const search = new URLSearchParams();
   if (params.year != null) search.set("year", String(params.year));
   if (params.limit != null) search.set("limit", String(params.limit));
+  if (params.offset != null) search.set("offset", String(params.offset));
   if (params.filingLimit != null) search.set("filingLimit", String(params.filingLimit));
+  if (params.filingOffset != null) search.set("filingOffset", String(params.filingOffset));
   if (params.member) search.set("member", params.member);
   if (params.ticker) search.set("ticker", params.ticker);
   if (params.refresh != null) search.set("refresh", String(params.refresh));
   return appendQuery("/cloud/congress/house", search);
 }
 
+export function cloudSecFilingsPath(params: CloudSecFilingsParams): string {
+  const search = new URLSearchParams({ ticker: params.ticker });
+  if (params.limit != null) search.set("limit", String(params.limit));
+  if (params.offset != null) search.set("offset", String(params.offset));
+  return appendQuery("/cloud/sec/filings", search);
+}
+
+export function cloudSecFilingDocumentsPath(params: CloudSecFilingParams): string {
+  const search = new URLSearchParams();
+  if (params.cik) search.set("cik", params.cik);
+  if (params.accession) search.set("accession", params.accession);
+  if (params.form) search.set("form", params.form);
+  if (params.primaryDocument) search.set("primaryDocument", params.primaryDocument);
+  if (params.filingUrl) search.set("filingUrl", params.filingUrl);
+  return appendQuery("/cloud/sec/filing/documents", search);
+}
+
+export function cloudSecFilingContentPath(params: CloudSecFilingParams): string {
+  const search = new URLSearchParams();
+  if (params.cik) search.set("cik", params.cik);
+  if (params.accession) search.set("accession", params.accession);
+  if (params.form) search.set("form", params.form);
+  if (params.primaryDocument) search.set("primaryDocument", params.primaryDocument);
+  if (params.primaryDocumentUrl) search.set("primaryDocumentUrl", params.primaryDocumentUrl);
+  if (params.filingUrl) search.set("filingUrl", params.filingUrl);
+  return appendQuery("/cloud/sec/filing/content", search);
+}
+
+export function cloudSec13FPath(path: string, params: Record<string, string | number | undefined> = {}): string {
+  const search = new URLSearchParams();
+  for (const [key, value] of Object.entries(params)) {
+    if (value !== undefined) search.set(key, String(value));
+  }
+  const normalized = path.startsWith("/") ? path.slice(1) : path;
+  return appendQuery(`/cloud/sec/13f/${normalized}`, search);
+}
+
 export function cloudNewsPath(params: CloudNewsParams = {}): string {
   const search = new URLSearchParams();
   if (params.feed) search.set("feed", params.feed);

package/src/api-client/request.ts

@@ -24,10 +24,14 @@ export function setCloudApiFetchTransport(transport: CloudApiFetchTransport | nu
 
 declare const __GLOOMBERB_API_URL__: string | undefined;
 
-function getCloudApiBaseUrl(): string {
+export function getCloudApiBaseUrl(): string {
   // Browser bundles have no `process`; the build replaces this with a literal.
   const bundled = typeof __GLOOMBERB_API_URL__ === "string" ? __GLOOMBERB_API_URL__ : "";
-  if (bundled) return bundled;
+  if (bundled) {
+    return typeof location !== "undefined" && bundled === location.origin
+      ? `${bundled}/api`
+      : bundled;
+  }
   if (typeof process === "undefined") {
     return DEFAULT_API_URL;
   }
@@ -43,6 +47,7 @@ export class CloudApiRequestTransport {
   private sessionToken: string | null = null;
   private sessionCookieName: SessionCookieName | null = null;
   private websocketToken: string | null = null;
+  private cookieSessionMode = false;
   private readonly fetchTransport: CloudApiFetchTransport | null;
   private readonly marketRequestTimeoutMs: number;
   private readonly connectionHealth: ConnectionHealthRegistry;
@@ -67,6 +72,14 @@ export class CloudApiRequestTransport {
     return this.websocketToken;
   }
 
+  hasSessionCredential(): boolean {
+    return this.cookieSessionMode || !!this.sessionToken;
+  }
+
+  setCookieSessionMode(enabled: boolean): void {
+    this.cookieSessionMode = enabled;
+  }
+
   setSessionToken(token: string | null): void {
     if (this.sessionToken !== token) {
       this.sessionCookieName = null;

package/src/api-client/socket-health.test.ts

@@ -50,6 +50,7 @@ describe("CloudApiSocket connection health", () => {
     const socket = new CloudApiSocket({
       getBaseUrl: () => `http://127.0.0.1:${server.port}`,
       getSocketAuthToken: () => null,
+      hasSessionCredential: () => false,
       hasVerifiedUser: () => false,
       isUsingWebSocketToken: () => false,
       clearWebSocketTokenForFallback: () => false,

package/src/api-client/socket.ts

@@ -49,6 +49,7 @@ function mergeQuoteStreamSubscriptions(
 type CloudApiSocketDelegate = {
   getBaseUrl: () => string;
   getSocketAuthToken: () => string | null;
+  hasSessionCredential: () => boolean;
   hasVerifiedUser: () => boolean;
   isUsingWebSocketToken: () => boolean;
   clearWebSocketTokenForFallback: () => boolean;
@@ -427,7 +428,7 @@ export class CloudApiSocket {
 
   private shouldKeepSocketOpen(): boolean {
     if (this.quoteTargets.size > 0 || this.scannerListeners.size > 0) return true;
-    return !!this.delegate.getSocketAuthToken()
+    return this.delegate.hasSessionCredential()
       && this.delegate.hasVerifiedUser()
       && this.channelListeners.size > 0;
   }

package/src/api-client/types.ts

@@ -322,6 +322,40 @@ export interface CloudFredSeriesPayload {
   info: CloudFredSeriesInfoPayload | null;
 }
 
+/** One publicly disseminated single-name CDS transaction report. */
+export interface CloudCdsTradePayload {
+  disseminationId: string;
+  originalDisseminationId: string | null;
+  actionType: string;
+  eventTimestamp: string;
+  executionTimestamp: string | null;
+  effectiveDate: string | null;
+  expirationDate: string | null;
+  maturityDate: string | null;
+  issuerName: string | null;
+  underlierId: string | null;
+  underlierIdSource: string | null;
+  upi: string | null;
+  upiFisn: string | null;
+  upiUnderlierName: string | null;
+  notionalAmount: number | null;
+  /** Reported notional is a regulatory cap, so the real trade was at least this size. */
+  notionalCapped: boolean;
+  notionalCurrency: string | null;
+  fixedRate: number | null;
+  reportedSpread: number | null;
+  /** Unit of `reportedSpread`, e.g. basis points or percent. */
+  spreadNotation: string | null;
+  upfrontAmount: number | null;
+  upfrontCurrency: string | null;
+}
+
+export interface CloudCdsResponse {
+  source: string;
+  asOf: string | null;
+  trades: CloudCdsTradePayload[];
+}
+
 export interface CloudShortInterestPointPayload {
   settlementDate: string;
   sharesShort: number;
@@ -399,10 +433,66 @@ export interface CloudCongressHousePayload {
   indexUpdatedAt: string | null;
   filingsScanned: number;
   filingCount: number;
+  filingOffset?: number;
+  hasMore?: boolean;
+  hasMoreFilings?: boolean;
+  nextOffset?: number;
+  nextFilingOffset?: number;
   trades: CloudCongressTradePayload[];
   members: CloudCongressMemberPayload[];
 }
 
+export interface CloudSecFilingPayload {
+  accessionNumber: string;
+  form: string;
+  filingDate: string;
+  acceptedAt?: string;
+  primaryDocument?: string;
+  primaryDocDescription?: string;
+  items?: string;
+  cik: string;
+  companyName?: string;
+  filingUrl: string;
+  primaryDocumentUrl?: string;
+}
+
+export interface CloudSecDocumentPayload {
+  sequence?: string;
+  type: string;
+  description?: string;
+  document: string;
+  url: string;
+  size?: string;
+  isPrimary: boolean;
+}
+
+export interface CloudSecFilingsResponse {
+  filings: CloudSecFilingPayload[];
+  hasMore: boolean;
+  nextOffset: number;
+}
+
+export interface CloudSecDocumentsResponse {
+  documents: CloudSecDocumentPayload[];
+}
+
+export interface CloudSecForm4Payload {
+  filingDate: string;
+  reportedName: string;
+  title: string;
+  transactionType: "P" | "S" | "A" | "D" | "";
+  shares: number;
+  pricePerShare: number | null;
+  totalValue: number | null;
+  sharesOwned: number | null;
+  form: string;
+}
+
+export interface CloudSecContentResponse {
+  content: string | null;
+  form4: CloudSecForm4Payload | null;
+}
+
 interface CloudNewsEntityPayload {
   id: string;
   entityType: string;
@@ -617,6 +707,79 @@ export interface CloudMarketScreenerPayload {
   items: CloudMarketScreenerItem[];
 }
 
+/** Cache reuse policy for one Equity Diagnostic request. */
+export type CloudEquityDiagnosticMode = "cache-first" | "refresh";
+
+export type CloudEquityDiagnosticFindingKind = "red_flag" | "green_flag" | "anomaly";
+
+/** 3 is the most severe. */
+export type CloudEquityDiagnosticSeverity = 1 | 2 | 3;
+
+export interface CloudEquityDiagnosticFinding {
+  id: string;
+  kind: CloudEquityDiagnosticFindingKind;
+  severity: CloudEquityDiagnosticSeverity;
+  confidence: number;
+  title: string;
+  /** What the data says, with no reading attached. */
+  observation: string;
+  /** What the observation may mean; kept apart from the observation on purpose. */
+  interpretation: string;
+  /** Ids into `evidence`; unresolved ids are dropped by the client. */
+  evidenceIds: string[];
+}
+
+export interface CloudEquityDiagnosticCoverage {
+  dataset: string;
+  status: "available" | "no_data" | "unsupported" | "failed";
+  asOf?: string;
+  provider?: string;
+  note?: string;
+}
+
+/** The server owns citation URLs; the client never builds them. */
+export interface CloudEquityDiagnosticEvidence {
+  id: string;
+  dataset: string;
+  label: string;
+  asOf?: string;
+  provider?: string;
+  url?: string;
+}
+
+export interface CloudEquityDiagnosticPending {
+  status: "generating";
+  retryAfterMs: number;
+}
+
+export interface CloudEquityDiagnosticResponse {
+  schemaVersion: 1;
+  access: "preview" | "full";
+  symbol: string;
+  exchange: string;
+  companyName?: string;
+  status: "complete" | "partial" | "insufficient_data";
+  verdict: "risk_skewed" | "balanced" | "opportunity_skewed" | "unclear";
+  summary: string;
+  confidence: number;
+  findings: CloudEquityDiagnosticFinding[];
+  watchItems: string[];
+  coverage: CloudEquityDiagnosticCoverage[];
+  evidence: CloudEquityDiagnosticEvidence[];
+  generatedAt: string;
+  expiresAt: string;
+  /** Before this instant a `refresh` request may still answer from cache. */
+  refreshAllowedAt: string;
+  cached: boolean;
+  stale: boolean;
+  promptVersion: 1;
+  model: "gpt-5.6-luna";
+}
+
+export type CloudEquityDiagnosticResult =
+  | CloudEquityDiagnosticPending
+  | CloudEquityDiagnosticResponse;
+
 export interface CloudVerificationResponse {
   sent: boolean;
   email?: string;

package/src/app/pane-runtime/index.tsx

@@ -11,6 +11,7 @@ import {
 import type { PluginRegistry } from "../../plugins/registry";
 import {
   getFocusedCollectionId,
+  resolveTickerForPane,
   syncConfigActiveLayoutState,
   type AppAction,
   type AppState,
@@ -75,7 +76,9 @@ export function useAppPaneRuntime({
 
   const persistLayout = useCallback((layout: LayoutConfig, options?: { pushHistory?: boolean; focusedPaneId?: string | null }) => {
     const currentState = stateRef.current;
-    const normalizedLayout = normalizePaneLayout(layout);
+    const normalizedLayout = normalizePaneLayout(layout, {
+      resolveOrphanSymbol: (instanceId) => resolveTickerForPane(currentState, instanceId),
+    });
     if (options?.pushHistory !== false) {
       dispatch({ type: "PUSH_LAYOUT_HISTORY" });
     }