gloomberb 0.11.3 → 0.12.0

package/src/i18n/zh-cn.ts

@@ -573,6 +573,7 @@ export const zhCN: Record<string, string> = {
   "Open the help window": "打开帮助窗口",
   "Set up a portfolio": "设置投资组合",
   "How would you like to get started?": "你想如何开始？",
+  "{shortcut} to get started.": "按 {shortcut} 开始。",
   "Edits later from the command bar.": "之后可在命令栏中修改。",
   "Create Manual Portfolio": "创建手动组合",
   "Add tickers and positions by hand": "手动添加股票与持仓",
@@ -775,7 +776,7 @@ export const zhCN: Record<string, string> = {
   "Verify your email to send messages.": "验证邮箱后才能发送消息。",
   "Verify your email to use Cloud tweets.": "验证邮箱后才能使用 Cloud tweets。",
   "Resend Verification Email": "重新发送验证邮件",
-  "Ctrl+P, then Resend Verification Email": "按 Ctrl+P，然后选择“重新发送验证邮件”",
+  "{shortcut}, then Resend Verification Email": "按 {shortcut}，然后选择“重新发送验证邮件”",
   "editing": "编辑中",
   "replying to": "回复",
   "Reply": "回复",
@@ -1013,7 +1014,7 @@ export const zhCN: Record<string, string> = {
   "No watchlist tickers": "自选列表暂无股票",
   "No tickers in {name}.": "{name} 中暂无股票。",
   "this collection": "此集合",
-  "Press Ctrl+P to add one.": "按 Ctrl+P 添加。",
+  "Press {shortcut} to add one.": "按 {shortcut} 添加。",
   "PRE-MKT": "盘前",
   "OPEN": "盘中",
   "AFTER-HRS": "盘后",
@@ -1079,6 +1080,9 @@ export const zhCN: Record<string, string> = {
   "Approve from your phone, no typing": "在手机上确认，无需输入",
   "Scan with the Gloom app": "用 Gloom 应用扫码",
   "Open the Gloom app on your phone and approve this workspace.": "在手机上打开 Gloom 应用并确认此工作区。",
+  "Approve the code from a phone that is already signed in.": "在已登录的手机上确认此代码。",
+  "Layouts, watchlists and portfolios sync to your account.": "布局、自选列表和投资组合会同步到你的账户。",
+  "Use email instead": "改用邮箱",
   "Scan with the Gloom app to sign in": "用 Gloom 应用扫码登录",
   "Waiting for approval...": "等待确认...",
   "Approved as {email}": "已以 {email} 登录",

package/src/i18n/zh-tw.ts

@@ -573,6 +573,7 @@ export const zhTW: Record<string, string> = {
   "Open the help window": "開啟說明視窗",
   "Set up a portfolio": "設定投資組合",
   "How would you like to get started?": "你想如何開始？",
+  "{shortcut} to get started.": "按 {shortcut} 開始。",
   "Edits later from the command bar.": "之後可在命令列中修改。",
   "Create Manual Portfolio": "建立手動投資組合",
   "Add tickers and positions by hand": "手動新增股票與持倉",
@@ -775,7 +776,7 @@ export const zhTW: Record<string, string> = {
   "Verify your email to send messages.": "驗證電子郵件後才能傳送訊息。",
   "Verify your email to use Cloud tweets.": "驗證電子郵件後才能使用 Cloud tweets。",
   "Resend Verification Email": "重新發送驗證郵件",
-  "Ctrl+P, then Resend Verification Email": "按 Ctrl+P，然後選擇「重新發送驗證郵件」",
+  "{shortcut}, then Resend Verification Email": "按 {shortcut}，然後選擇「重新發送驗證郵件」",
   "editing": "編輯中",
   "replying to": "回覆",
   "Reply": "回覆",
@@ -1013,7 +1014,7 @@ export const zhTW: Record<string, string> = {
   "No watchlist tickers": "自選清單暫無股票",
   "No tickers in {name}.": "{name} 中暫無股票。",
   "this collection": "此清單",
-  "Press Ctrl+P to add one.": "按 Ctrl+P 新增。",
+  "Press {shortcut} to add one.": "按 {shortcut} 新增。",
   "PRE-MKT": "盤前",
   "OPEN": "盤中",
   "AFTER-HRS": "盤後",
@@ -1079,6 +1080,9 @@ export const zhTW: Record<string, string> = {
   "Approve from your phone, no typing": "在手機上確認，無需輸入",
   "Scan with the Gloom app": "用 Gloom 應用程式掃碼",
   "Open the Gloom app on your phone and approve this workspace.": "在手機上開啟 Gloom 應用程式並確認此工作區。",
+  "Approve the code from a phone that is already signed in.": "在已登入的手機上確認這組代碼。",
+  "Layouts, watchlists and portfolios sync to your account.": "版面、自選清單與投資組合會同步到你的帳號。",
+  "Use email instead": "改用電子郵件",
   "Scan with the Gloom app to sign in": "用 Gloom 應用程式掃碼登入",
   "Waiting for approval...": "等待確認...",
   "Approved as {email}": "已以 {email} 登入",

package/src/layout-marketplace/pane-imagery.ts

@@ -22,6 +22,7 @@ const IMAGERY_RULES: ReadonlyArray<readonly [string, PaneImagery]> = [
   ["sectors", "heatmap"],
   ["treemap", "heatmap"],
   ["fear-greed", "gauge"],
+  ["valuation", "chart"],
   ["kelly", "gauge"],
   ["gauge", "gauge"],
   ["calendar", "calendar"],

package/src/layout-marketplace/payload.test.ts

@@ -157,6 +157,23 @@ describe("layout marketplace payloads", () => {
     expect(JSON.stringify(pane)).not.toContain("secret");
   });
 
+  test("drops cache-sized pane state instead of failing the share", () => {
+    const pane = publishableMarketplacePane({
+      instanceId: "news-top:main",
+      paneId: "prediction-markets",
+      binding: { kind: "none" },
+    }, {
+      sort: { columnId: "time", direction: "desc" },
+      "news-top:articles": Array.from({ length: 400 }, (_, index) => ({
+        id: `article-${index}`,
+        title: "x".repeat(200),
+        publishedAt: "2026-08-26T00:00:00.000Z",
+      })),
+    }, panes);
+
+    expect(pane.paneState.p1).toEqual({ sort: { columnId: "time", direction: "desc" } });
+  });
+
   test("shares portable pane setup and state while redacting private data", () => {
     const fixture = portableFixture();
     const payload = publishableMarketplaceLayout(fixture.layout, fixture.paneState, panes);

package/src/layout-marketplace/payload.ts

@@ -12,6 +12,10 @@ import type {
 } from "../types/plugin";
 
 const MAX_LAYOUT_BYTES = 128 * 1024;
+// Pane runtime state doubles as a cache (news panes keep six figures of bytes of
+// article backlog), so bulky fields drop out of the share rather than failing
+// the whole publish.
+const MAX_PANE_STATE_FIELD_BYTES = 16 * 1024;
 const MAX_INSTANCES = 40;
 const MAX_DOCK_DEPTH = 20;
 const MAX_ID_LENGTH = 160;
@@ -493,14 +497,45 @@ function publishableLayout(
       height,
     })),
   };
-  const parsed = parseMarketplaceLayoutPayload({
+  let publishableState = Object.fromEntries(
+    Object.entries(projectedState).flatMap(([id, state]) => {
+      const trimmed = withoutCacheFields(state);
+      return Object.keys(trimmed).length > 0 ? [[id, trimmed] as const] : [];
+    }),
+  );
+  let parsed = parsePublishablePayload(projected, publishableState);
+  while (!parsed && Object.keys(publishableState).length > 0) {
+    publishableState = withoutLargestState(publishableState);
+    parsed = parsePublishablePayload(projected, publishableState);
+  }
+  if (!parsed) throw new Error("This layout cannot be published safely.");
+  return parsed;
+}
+
+function parsePublishablePayload(
+  layout: LayoutConfig,
+  paneState: Record<string, PaneRuntimeState>,
+): LayoutMarketplacePayload | null {
+  return parseMarketplaceLayoutPayload({
     schemaVersion: 2,
     sourceConfigVersion: CURRENT_CONFIG_VERSION,
-    layout: projected,
-    paneState: projectedState,
+    layout,
+    paneState,
   });
-  if (!parsed) throw new Error("This layout cannot be published safely.");
-  return parsed;
+}
+
+function withoutCacheFields(state: PaneRuntimeState): PaneRuntimeState {
+  return Object.fromEntries(
+    Object.entries(state).filter(([, value]) => encodedSize(value) <= MAX_PANE_STATE_FIELD_BYTES),
+  ) as PaneRuntimeState;
+}
+
+function withoutLargestState(
+  paneState: Record<string, PaneRuntimeState>,
+): Record<string, PaneRuntimeState> {
+  const largest = Object.entries(paneState)
+    .reduce((worst, entry) => (encodedSize(entry[1]) > encodedSize(worst[1]) ? entry : worst));
+  return Object.fromEntries(Object.entries(paneState).filter(([id]) => id !== largest[0]));
 }
 
 export function publishableMarketplaceLayout(

package/src/market-data/coordinator/index.ts

@@ -55,7 +55,8 @@ import {
   loadQuoteBatchEntries,
   loadQuoteEntry,
   QuoteSubscriptionManager,
-  type QuoteSubscriptionPriority,
+  type QuoteSubscriptionHandle,
+  type QuoteSubscriptionRequest,
 } from "./quotes";
 
 export class MarketDataCoordinator {
@@ -361,7 +362,7 @@ export class MarketDataCoordinator {
     });
   }
 
-  subscribeQuotes(targets: Array<{ instrument: InstrumentRef; priority?: QuoteSubscriptionPriority }>): () => void {
+  subscribeQuotes(targets: QuoteSubscriptionRequest[]): QuoteSubscriptionHandle {
     return this.quoteSubscriptionManager.subscribe(targets);
   }
 

package/src/market-data/coordinator/quotes.ts

@@ -19,6 +19,21 @@ import {
 
 export type QuoteSubscriptionPriority = Pick<QuoteSubscriptionTarget, "route" | "surface" | "visible" | "selected" | "weight">;
 
+export interface QuoteSubscriptionRequest {
+  instrument: InstrumentRef;
+  priority?: QuoteSubscriptionPriority;
+}
+
+/**
+ * Remains callable for compatibility with the original disposer API. Updating
+ * the handle lets long-lived consumers change priorities without unregistering
+ * their whole target set first.
+ */
+export interface QuoteSubscriptionHandle {
+  (): void;
+  update(targets: QuoteSubscriptionRequest[]): void;
+}
+
 export interface QuoteSubscriptionEntry {
   target: QuoteSubscriptionTarget;
   targets: Map<number, QuoteSubscriptionTarget>;
@@ -30,7 +45,8 @@ interface PendingStreamQuote {
   quote: Quote;
 }
 
-const QUOTE_SUBSCRIPTION_REMOVE_GRACE_MS = 250;
+export const QUOTE_SUBSCRIPTION_REMOVE_GRACE_MS = 250;
+export const QUOTE_SUBSCRIPTION_PRIORITY_UPDATE_DELAY_MS = 100;
 
 const STREAM_QUOTE_FIELDS: Array<keyof Quote> = [
   "symbol",
@@ -198,101 +214,192 @@ export class QuoteSubscriptionManager {
   private readonly pendingStreamQuotes = new Map<string, PendingStreamQuote>();
   private lastStreamQuoteBatchAppliedAt: number | null = null;
   private pendingStreamQuoteTimer: ReturnType<typeof setTimeout> | null = null;
+  private pendingPriorityUpdateTimer: ReturnType<typeof setTimeout> | null = null;
   private nextQuoteSubscriptionId = 1;
   private quoteSubscriptionDispose: (() => void) | null = null;
   private quoteSubscriptionSignature = "";
+  private quoteSubscriptionRoutingSignature = "";
 
   constructor(
     private readonly dataProvider: DataProvider,
     private readonly applyQuote: (instrument: InstrumentRef, quote: Quote) => void,
   ) {}
 
-  subscribe(targets: Array<{ instrument: InstrumentRef; priority?: QuoteSubscriptionPriority }>): () => void {
-    if (!this.dataProvider.subscribeQuotes || targets.length === 0) {
-      return () => {};
+  subscribe(targets: QuoteSubscriptionRequest[]): QuoteSubscriptionHandle {
+    if (!this.dataProvider.subscribeQuotes) {
+      return this.createNoopSubscription();
     }
 
     const subscriptionId = this.nextQuoteSubscriptionId++;
-    const subscribedKeys = new Set<string>();
+    let subscribedKeys = new Set<string>();
+    let disposed = false;
+    const update = (nextTargets: QuoteSubscriptionRequest[]) => {
+      if (disposed) return;
+      subscribedKeys = this.updateSubscriptionTargets(subscriptionId, subscribedKeys, nextTargets);
+    };
+    const dispose = (() => {
+      if (disposed) return;
+      disposed = true;
+      subscribedKeys = this.updateSubscriptionTargets(subscriptionId, subscribedKeys, []);
+    }) as QuoteSubscriptionHandle;
+    dispose.update = update;
+    update(targets);
+    return dispose;
+  }
+
+  private createNoopSubscription(): QuoteSubscriptionHandle {
+    const dispose = (() => {}) as QuoteSubscriptionHandle;
+    dispose.update = () => {};
+    return dispose;
+  }
+
+  private updateSubscriptionTargets(
+    subscriptionId: number,
+    subscribedKeys: Set<string>,
+    targets: QuoteSubscriptionRequest[],
+  ): Set<string> {
+    const nextTargets = new Map<string, QuoteSubscriptionTarget>();
     for (const { instrument, priority } of targets) {
       const key = buildQuoteKey(instrument);
-      subscribedKeys.add(key);
       const target = quoteTargetFromInstrument(instrument, priority);
-      const existing = this.quoteSubscriptions.get(key);
-      if (existing) {
-        existing.targets.set(subscriptionId, target);
-        existing.target = mergeQuoteSubscriptionTargets(existing.targets.values()) ?? target;
-        if (existing.removeTimer) {
-          clearTimeout(existing.removeTimer);
-          existing.removeTimer = null;
+      const duplicate = nextTargets.get(key);
+      nextTargets.set(
+        key,
+        duplicate
+          ? mergeQuoteSubscriptionTargets([duplicate, target]) ?? target
+          : target,
+      );
+    }
+
+    const nextKeys = new Set(nextTargets.keys());
+    const affectedKeys = new Set([...subscribedKeys, ...nextKeys]);
+    let shouldFlush = false;
+    for (const key of affectedKeys) {
+      const nextTarget = nextTargets.get(key);
+      let entry = this.quoteSubscriptions.get(key);
+      if (nextTarget) {
+        if (!entry) {
+          entry = {
+            target: nextTarget,
+            targets: new Map(),
+            removeTimer: null,
+          };
+          this.quoteSubscriptions.set(key, entry);
         }
+        entry.targets.set(subscriptionId, nextTarget);
+        if (entry.removeTimer) {
+          clearTimeout(entry.removeTimer);
+          entry.removeTimer = null;
+        }
+      } else if (entry) {
+        entry.targets.delete(subscriptionId);
+      }
+      if (!entry) continue;
+
+      const mergedTarget = mergeQuoteSubscriptionTargets(entry.targets.values());
+      if (mergedTarget) {
+        entry.target = mergedTarget;
+        shouldFlush = true;
         continue;
       }
-      this.quoteSubscriptions.set(key, {
-        target,
-        targets: new Map([[subscriptionId, target]]),
-        removeTimer: null,
-      });
+      this.scheduleSubscriptionRemoval(key, entry);
     }
-    this.flush();
-
-    return () => {
-      for (const key of subscribedKeys) {
-        const existing = this.quoteSubscriptions.get(key);
-        if (!existing) continue;
-        existing.targets.delete(subscriptionId);
-        const mergedTarget = mergeQuoteSubscriptionTargets(existing.targets.values());
-        if (mergedTarget) {
-          existing.target = mergedTarget;
-          this.flush();
-          continue;
-        }
-        if (existing.removeTimer) continue;
-        this.clearPendingStreamQuote(key);
-        existing.removeTimer = setTimeout(() => {
-          const current = this.quoteSubscriptions.get(key);
-          if (!current || current.targets.size > 0) return;
-          this.quoteSubscriptions.delete(key);
-          this.clearPendingStreamQuote(key);
-          this.flush();
-        }, QUOTE_SUBSCRIPTION_REMOVE_GRACE_MS);
-      }
-    };
+    if (shouldFlush) {
+      this.flush();
+    } else if (![...this.quoteSubscriptions.values()].some((entry) => entry.targets.size > 0)) {
+      this.cancelPendingPriorityUpdate();
+    }
+    return nextKeys;
+  }
+
+  private scheduleSubscriptionRemoval(key: string, entry: QuoteSubscriptionEntry): void {
+    if (entry.removeTimer) return;
+    this.clearPendingStreamQuote(key);
+    entry.removeTimer = setTimeout(() => {
+      const current = this.quoteSubscriptions.get(key);
+      if (!current || current.targets.size > 0) return;
+      this.quoteSubscriptions.delete(key);
+      this.clearPendingStreamQuote(key);
+      this.flush();
+    }, QUOTE_SUBSCRIPTION_REMOVE_GRACE_MS);
   }
 
-  private flush(): void {
+  private flush({
+    coalescePriorityChanges = true,
+    requireStableRouting = false,
+  }: {
+    coalescePriorityChanges?: boolean;
+    requireStableRouting?: boolean;
+  } = {}): void {
     if (!this.dataProvider.subscribeQuotes) return;
 
     const activeEntries = [...this.quoteSubscriptions.entries()]
       .filter(([, entry]) => entry.targets.size > 0)
       .sort(([left], [right]) => left.localeCompare(right));
-    const nextSignature = activeEntries.map(([key, entry]) => [
+    const nextRoutingSignature = JSON.stringify(activeEntries.map(([key, entry]) => [
       key,
-      entry.target.route ?? "",
+      entry.target.route ?? "auto",
+    ]));
+    const nextSignature = JSON.stringify(activeEntries.map(([key, entry]) => [
+      key,
+      entry.target.route ?? "auto",
       entry.target.surface ?? "",
-      entry.target.visible ? "visible" : "",
-      entry.target.selected ? "selected" : "",
-      Number.isFinite(entry.target.weight) ? entry.target.weight : "",
-    ].join(":")).join("|");
-    if (nextSignature === this.quoteSubscriptionSignature) return;
-
-    this.quoteSubscriptionDispose?.();
-    this.quoteSubscriptionDispose = null;
-    this.quoteSubscriptionSignature = nextSignature;
+      entry.target.visible === true,
+      entry.target.selected === true,
+      Number.isFinite(entry.target.weight) ? entry.target.weight : null,
+    ]));
+    if (nextSignature === this.quoteSubscriptionSignature) {
+      this.cancelPendingPriorityUpdate();
+      return;
+    }
+    if (requireStableRouting && nextRoutingSignature !== this.quoteSubscriptionRoutingSignature) {
+      return;
+    }
+
+    const priorityOnlyChange = this.quoteSubscriptionSignature.length > 0
+      && nextRoutingSignature === this.quoteSubscriptionRoutingSignature;
+    if (coalescePriorityChanges && priorityOnlyChange) {
+      this.schedulePriorityUpdate();
+      return;
+    }
+    this.cancelPendingPriorityUpdate();
 
     const targets = activeEntries.map(([, entry]) => entry.target);
-    if (targets.length === 0) return;
-
-    this.quoteSubscriptionDispose = this.dataProvider.subscribeQuotes(targets, (target, quote) => {
-      const instrument: InstrumentRef = {
-        symbol: target.symbol,
-        exchange: target.exchange ?? "",
-        brokerId: target.context?.brokerId,
-        brokerInstanceId: target.context?.brokerInstanceId,
-        instrument: target.context?.instrument ?? null,
-      };
-      this.enqueueStreamQuote(instrument, quote);
-    });
+    const nextDispose = targets.length > 0
+      ? this.dataProvider.subscribeQuotes(targets, (target, quote) => {
+          const instrument: InstrumentRef = {
+            symbol: target.symbol,
+            exchange: target.exchange ?? "",
+            brokerId: target.context?.brokerId,
+            brokerInstanceId: target.context?.brokerInstanceId,
+            instrument: target.context?.instrument ?? null,
+          };
+          this.enqueueStreamQuote(instrument, quote);
+        })
+      : null;
+    // Register first so the cloud socket and desktop registries can merge the
+    // overlapping listeners without observing a zero-listener disconnect.
+    const previousDispose = this.quoteSubscriptionDispose;
+    this.quoteSubscriptionDispose = nextDispose;
+    this.quoteSubscriptionSignature = nextSignature;
+    this.quoteSubscriptionRoutingSignature = nextRoutingSignature;
+    previousDispose?.();
+  }
+
+  private schedulePriorityUpdate(): void {
+    // Do not reset this timer. Continuous navigation must still publish the
+    // latest priorities instead of postponing them indefinitely.
+    if (this.pendingPriorityUpdateTimer !== null) return;
+    this.pendingPriorityUpdateTimer = setTimeout(() => {
+      this.pendingPriorityUpdateTimer = null;
+      this.flush({ coalescePriorityChanges: false, requireStableRouting: true });
+    }, QUOTE_SUBSCRIPTION_PRIORITY_UPDATE_DELAY_MS);
+  }
+
+  private cancelPendingPriorityUpdate(): void {
+    if (this.pendingPriorityUpdateTimer === null) return;
+    clearTimeout(this.pendingPriorityUpdateTimer);
+    this.pendingPriorityUpdateTimer = null;
   }
 
   private enqueueStreamQuote(instrument: InstrumentRef, quote: Quote): void {