gloomberb 0.9.8 → 0.9.10

package/src/plugins/registry/contributions.ts

@@ -37,6 +37,11 @@ interface RegistryContributionsOptions {
   wrapBrokerAdapter?: (broker: BrokerAdapter, pluginId: string) => BrokerAdapter;
 }
 
+function setUnique<T>(map: Map<string, T>, id: string, value: T): void {
+  if (map.has(id)) throw new Error(`Duplicate plugin contribution id: ${id}`);
+  map.set(id, value);
+}
+
 export class RegistryContributions {
   readonly pluginItems = new Map<string, PluginItems>();
   readonly commandOwners = new Map<string, string>();
@@ -82,30 +87,30 @@ export class RegistryContributions {
   }
 
   registerPane(pluginId: string, pane: PaneDef, items = this.getOrCreatePluginItems(pluginId)): void {
-    this.panesMap.set(pane.id, this.options.wrapPaneDef(pluginId, pane));
+    setUnique(this.panesMap, pane.id, this.options.wrapPaneDef(pluginId, pane));
     this.paneOwners.set(pane.id, pluginId);
     items.panes.push(pane.id);
   }
 
   registerPaneTemplate(pluginId: string, template: PaneTemplateDef, items = this.getOrCreatePluginItems(pluginId)): void {
-    this.paneTemplatesMap.set(template.id, template);
+    setUnique(this.paneTemplatesMap, template.id, template);
     this.paneTemplateOwners.set(template.id, pluginId);
     items.paneTemplates.push(template.id);
   }
 
   registerCommand(pluginId: string, command: CommandDef, items = this.getOrCreatePluginItems(pluginId)): void {
-    this.commandsMap.set(command.id, command);
+    setUnique(this.commandsMap, command.id, command);
     this.commandOwners.set(command.id, pluginId);
     items.commands.push(command.id);
   }
 
   registerColumn(_pluginId: string, column: CustomColumnDef, items: PluginItems): void {
-    this.columnsMap.set(column.id, column);
+    setUnique(this.columnsMap, column.id, column);
     items.columns.push(column.id);
   }
 
   registerBroker(pluginId: string, broker: BrokerAdapter, items = this.getOrCreatePluginItems(pluginId)): void {
-    this.brokersMap.set(broker.id, this.options.wrapBrokerAdapter?.(broker, pluginId) ?? broker);
+    setUnique(this.brokersMap, broker.id, this.options.wrapBrokerAdapter?.(broker, pluginId) ?? broker);
     items.brokers.push(broker.id);
   }
 
@@ -115,19 +120,19 @@ export class RegistryContributions {
   }
 
   registerTickerResearchTab(pluginId: string, tab: TickerResearchTabDef, items = this.getOrCreatePluginItems(pluginId)): void {
-    this.tickerResearchTabsMap.set(tab.id, this.options.wrapTickerResearchTabDef(pluginId, tab));
+    setUnique(this.tickerResearchTabsMap, tab.id, this.options.wrapTickerResearchTabDef(pluginId, tab));
     this.tickerResearchTabOwners.set(tab.id, pluginId);
     items.tickerResearchTabs.push(tab.id);
   }
 
   registerShortcut(pluginId: string, shortcut: KeyboardShortcut, items = this.getOrCreatePluginItems(pluginId)): void {
-    this.shortcutsMap.set(shortcut.id, shortcut);
+    setUnique(this.shortcutsMap, shortcut.id, shortcut);
     this.shortcutOwners.set(shortcut.id, pluginId);
     items.shortcuts.push(shortcut.id);
   }
 
   registerTickerAction(_pluginId: string, action: TickerAction, items: PluginItems): void {
-    this.tickerActionsMap.set(action.id, action);
+    setUnique(this.tickerActionsMap, action.id, action);
     items.tickerActions.push(action.id);
   }
 
@@ -166,9 +171,15 @@ export class RegistryContributions {
     }
     for (const actionId of items.tickerActions) this.tickerActionsMap.delete(actionId);
     for (const providerKey of items.contextMenuProviders) this.contextMenuProvidersMap.delete(providerKey);
-    for (const dispose of items.eventDisposers) dispose();
-    for (const dispose of items.capabilityDisposers) dispose();
-    for (const dispose of items.newsQueryWatchDisposers) dispose();
+    let disposeError: unknown;
+    for (const dispose of [...items.eventDisposers, ...items.capabilityDisposers, ...items.newsQueryWatchDisposers]) {
+      try {
+        dispose();
+      } catch (error) {
+        disposeError ??= error;
+      }
+    }
     this.pluginItems.delete(pluginId);
+    if (disposeError) throw disposeError;
   }
 }

package/src/plugins/registry/index.test.ts

@@ -70,6 +70,49 @@ afterEach(() => {
   currentPersistence = null;
 });
 
+describe("PluginRegistry lifecycle", () => {
+  test("rolls back rejected registrations and always removes owned contributions", async () => {
+    const registry = createRegistry();
+    const pane = {
+      id: "shared-pane",
+      name: "Shared",
+      component: () => null,
+      defaultPosition: "right" as const,
+    };
+
+    await expect(registry.register({
+      id: "setup-failure",
+      name: "Setup failure",
+      version: "1.0.0",
+      panes: [pane],
+      setup: () => { throw new Error("setup failed"); },
+    })).rejects.toThrow("setup failed");
+    expect(registry.allPlugins.has("setup-failure")).toBe(false);
+    expect(registry.panes.has("shared-pane")).toBe(false);
+
+    await registry.register({ id: "owner", name: "Owner", version: "1.0.0", panes: [pane] });
+    await expect(registry.register({ id: "collision", name: "Collision", version: "1.0.0", panes: [pane] }))
+      .rejects.toThrow("Duplicate plugin contribution id");
+    expect(registry.panes.get("shared-pane")?.name).toBe("Shared");
+
+    await registry.register({
+      id: "throwing-dispose",
+      name: "Throwing dispose",
+      version: "1.0.0",
+      panes: [{
+        id: "disposable-pane",
+        name: "Disposable",
+        component: () => null,
+        defaultPosition: "right",
+      }],
+      dispose: () => { throw new Error("dispose failed"); },
+    });
+    expect(() => registry.unregister("throwing-dispose")).toThrow("dispose failed");
+    expect(registry.allPlugins.has("throwing-dispose")).toBe(false);
+    expect(registry.panes.has("disposable-pane")).toBe(false);
+  });
+});
+
 describe("PluginRegistry context menu providers", () => {
   test("registers and unregisters context menu providers", async () => {
     const registry = createRegistry();
@@ -234,6 +277,7 @@ describe("PluginRegistry pane settings", () => {
         settings: {},
       }],
       floating: [],
+      detached: [],
     };
     registry.getConfigFn = () => config;
     registry.getLayoutFn = () => config.layout;

package/src/plugins/registry/index.ts

@@ -441,35 +441,47 @@ export class PluginRegistry implements PluginRuntimeAccess {
 
   async register(plugin: GloomPlugin): Promise<void> {
     this.registryLog.info(`Registering plugin: ${plugin.id} v${plugin.version ?? "?"}`);
-    const items = this.contributions.getOrCreatePluginItems(plugin.id);
-    if (plugin.panes) {
-      for (const pane of plugin.panes) {
-        this.contributions.registerPane(plugin.id, pane, items);
+    if (this.plugins.has(plugin.id)) throw new Error(`Plugin already registered: ${plugin.id}`);
+    this.plugins.set(plugin.id, plugin);
+    try {
+      const items = this.contributions.getOrCreatePluginItems(plugin.id);
+      if (plugin.panes) {
+        for (const pane of plugin.panes) {
+          this.contributions.registerPane(plugin.id, pane, items);
+        }
       }
-    }
 
-    if (plugin.paneTemplates) {
-      for (const template of plugin.paneTemplates) {
-        this.contributions.registerPaneTemplate(plugin.id, template, items);
+      if (plugin.paneTemplates) {
+        for (const template of plugin.paneTemplates) {
+          this.contributions.registerPaneTemplate(plugin.id, template, items);
+        }
       }
-    }
-
-    if (plugin.broker) {
-      this.contributions.registerBroker(plugin.id, plugin.broker, items);
-    }
 
-    if (this.enableCapabilityHandlers && plugin.capabilities) {
-      for (const capability of plugin.capabilities) {
-        this.registerCapabilityForPlugin(plugin.id, capability, items);
+      if (plugin.broker) {
+        this.contributions.registerBroker(plugin.id, plugin.broker, items);
       }
-    }
 
-    this.slots.register(plugin, this);
+      if (this.enableCapabilityHandlers && plugin.capabilities) {
+        for (const capability of plugin.capabilities) {
+          this.registerCapabilityForPlugin(plugin.id, capability, items);
+        }
+      }
 
-    this.plugins.set(plugin.id, plugin);
+      this.slots.register(plugin, this);
 
-    if (plugin.setup) {
-      await plugin.setup(this.createContext(plugin.id));
+      if (plugin.setup) {
+        await plugin.setup(this.createContext(plugin.id));
+      }
+    } catch (error) {
+      try {
+        this.removePlugin(plugin.id);
+      } catch (cleanupError) {
+        this.registryLog.error("Failed to clean up rejected plugin registration", {
+          pluginId: plugin.id,
+          error: cleanupError instanceof Error ? cleanupError.message : String(cleanupError),
+        });
+      }
+      throw error;
     }
 
     this.events.emit("plugin:registered", { pluginId: plugin.id });
@@ -480,13 +492,19 @@ export class PluginRegistry implements PluginRuntimeAccess {
     if (!plugin) return;
     this.registryLog.info(`Unregistering plugin: ${pluginId}`);
 
-    plugin.dispose?.();
-    this.slots.unregister(pluginId);
-
-    this.contributions.unregister(pluginId);
+    this.removePlugin(pluginId);
+    this.events.emit("plugin:unregistered", { pluginId });
+  }
 
+  private removePlugin(pluginId: string): void {
+    const plugin = this.plugins.get(pluginId);
+    if (!plugin) return;
+    let cleanupError: unknown;
+    try { plugin.dispose?.(); } catch (error) { cleanupError = error; }
+    try { this.slots.unregister(pluginId); } catch (error) { cleanupError ??= error; }
+    try { this.contributions.unregister(pluginId); } catch (error) { cleanupError ??= error; }
     this.plugins.delete(pluginId);
-    this.events.emit("plugin:unregistered", { pluginId });
+    if (cleanupError) throw cleanupError;
   }
 
   destroy(): void {

package/src/remote/controller.ts

@@ -51,7 +51,6 @@ interface AppRemoteControllerOptions {
 }
 
 const DEFAULT_MUTATION_INCLUDE: RemoteStateInclude[] = ["app", "layout", "panes", "commandBar"];
-const DEFAULT_BATCH_INCLUDE: RemoteStateInclude[] = ["app", "layout", "panes", "commandBar"];
 
 export function createAppRemoteController({
   dispatch,
@@ -68,11 +67,6 @@ export function createAppRemoteController({
     uiRegistry,
   });
 
-  const getAfterMutation = async (resource: string): Promise<unknown> => {
-    await afterMutation();
-    return getResource(resource);
-  };
-
   const getAfterMutationSummary = async (extra?: Record<string, unknown>): Promise<unknown> => {
     await afterMutation();
     return mutationSummary(getState(), extra);
@@ -420,7 +414,7 @@ export function createAppRemoteController({
             ok: responses.every((response) => response.ok),
             haltedAt,
             responses,
-          }, undefined, buildIncludedState(request.include, request.dryRun ? [] : DEFAULT_BATCH_INCLUDE));
+          }, undefined, buildIncludedState(request.include, request.dryRun ? [] : DEFAULT_MUTATION_INCLUDE));
         }
         default:
           throw new Error(`Unknown remote request type: ${(request as { type?: unknown }).type}`);

package/src/remote/json-patch.ts

@@ -12,6 +12,14 @@ function pointerSegments(path: string): string[] {
   return path.slice(1).split("/").map(decodePointerSegment);
 }
 
+const UNSAFE_OBJECT_KEYS = new Set(["__proto__", "constructor", "prototype"]);
+
+function assertSafeObjectKey(key: string): void {
+  if (UNSAFE_OBJECT_KEYS.has(key)) {
+    throw new Error(`Unsafe object key in JSON patch path: ${key}`);
+  }
+}
+
 function cloneJson<T>(value: T): T {
   return value == null ? value : JSON.parse(JSON.stringify(value)) as T;
 }
@@ -30,12 +38,18 @@ function containerFor(root: unknown, path: string): { parent: unknown; key: stri
       }
       parent = parent[index];
     } else if (parent && typeof parent === "object") {
+      assertSafeObjectKey(segment);
+      if (!Object.prototype.hasOwnProperty.call(parent, segment)) {
+        throw new Error(`Cannot descend into missing object key: ${segment}`);
+      }
       parent = (parent as Record<string, unknown>)[segment];
     } else {
       throw new Error(`Cannot descend into non-object patch path: ${path}`);
     }
   }
-  return { parent, key: segments[segments.length - 1]! };
+  const key = segments[segments.length - 1]!;
+  if (!Array.isArray(parent)) assertSafeObjectKey(key);
+  return { parent, key };
 }
 
 function applyOperation(root: unknown, operation: RemoteJsonPatchOperation): void {

package/src/remote/server.ts

@@ -45,21 +45,31 @@ export async function startRemoteControlServer(options: RemoteControlServerOptio
     token,
     startedAt: new Date().toISOString(),
   };
-  await writeRemoteEndpointFiles(options.dataDir, endpoint);
+  try {
+    await writeRemoteEndpointFiles(options.dataDir, endpoint);
+  } catch (error) {
+    await closeHttpServer(httpServer);
+    await removeRemoteEndpointFiles(options.dataDir, endpoint).catch(() => {});
+    throw error;
+  }
 
   return {
     endpoint,
     close: async () => {
-      await new Promise<void>((resolve, reject) => {
-        httpServer.close((error) => (error ? reject(error) : resolve()));
-      }).catch((error) => {
-        if ((error as NodeJS.ErrnoException).code !== "ERR_SERVER_NOT_RUNNING") throw error;
-      });
+      await closeHttpServer(httpServer);
       await removeRemoteEndpointFiles(options.dataDir, endpoint);
     },
   };
 }
 
+async function closeHttpServer(httpServer: ReturnType<typeof createServer>): Promise<void> {
+  await new Promise<void>((resolve, reject) => {
+    httpServer.close((error) => (error ? reject(error) : resolve()));
+  }).catch((error) => {
+    if ((error as NodeJS.ErrnoException).code !== "ERR_SERVER_NOT_RUNNING") throw error;
+  });
+}
+
 async function handleHttpRequest(
   handle: RemoteControlServerOptions["handle"],
   token: string,

package/src/renderers/electrobun/bun/application-menu/index.ts

@@ -26,7 +26,7 @@ function openCommandBar(label: string, query: string, options?: { accelerator?:
   return commandItem(label, { type: "open-command-bar", query }, options);
 }
 
-export function buildApplicationMenu(): ApplicationMenuItemConfig[] {
+function buildApplicationMenu(): ApplicationMenuItemConfig[] {
   return [
     {
       label: "Gloomberb",

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

@@ -19,6 +19,7 @@ const NOTES_INDEX_FILE = "__quick-notes-index__.json";
 const BROKER_INVOKE_OPERATIONS = new Set([
   "validate",
   "importPositions",
+  "importPortfolioSnapshot",
   "connect",
   "disconnect",
   "getPersistedConfigUpdate",
@@ -96,6 +97,7 @@ function invokeBrokerOperation(
   switch (operation) {
     case "validate":
     case "importPositions":
+    case "importPortfolioSnapshot":
     case "connect":
     case "disconnect":
     case "getPersistedConfigUpdate":

package/src/renderers/electrobun/bun/desktop/http-fetch.test.ts

@@ -39,4 +39,18 @@ describe("handleHttpFetch", () => {
     expect(response.headers.location).toBe("/reader");
     expect(response.setCookie).toEqual(["substack.sid=sid123; Path=/; HttpOnly"]);
   });
+
+  test("aborts the backend fetch at the requested deadline", async () => {
+    server = Bun.serve({
+      port: 0,
+      fetch() {
+        return new Promise<Response>(() => {});
+      },
+    });
+
+    await expect(handleHttpFetch({
+      url: server.url.toString(),
+      init: { timeoutMs: 10 },
+    })).rejects.toThrow();
+  });
 });

package/src/renderers/electrobun/bun/desktop/http-fetch.ts

@@ -34,12 +34,20 @@ export async function handleHttpFetch(payload: Record<string, unknown>) {
     typeof init.body === "string" && method !== "GET" && method !== "HEAD"
       ? init.body
       : undefined;
+  const timeoutMs =
+    typeof init.timeoutMs === "number"
+      && Number.isFinite(init.timeoutMs)
+      && init.timeoutMs > 0
+      && init.timeoutMs <= 120_000
+      ? init.timeoutMs
+      : undefined;
 
   const response = await fetch(url, {
     method,
     headers: normalizeHttpFetchHeaders(init.headers),
     body,
     redirect,
+    signal: timeoutMs ? AbortSignal.timeout(timeoutMs) : undefined,
   });
   const responseHeaders: Record<string, string> = {};
   response.headers.forEach((value, key) => {

package/src/renderers/electrobun/bun/desktop/initialization.ts

@@ -1,4 +1,5 @@
 import { existsSync, mkdirSync } from "fs";
+import { homedir } from "os";
 import { join } from "path";
 import { createAppServices, type AppServices } from "../../../../core/app-services";
 import type { AppSessionSnapshot } from "../../../../core/state/session-persistence";
@@ -98,7 +99,7 @@ function buildInitializationPayload(
 }
 
 async function resolveDesktopDataDir(): Promise<string> {
-  const dataDir = await getDataDir() ?? join(process.env.HOME || "~", ".gloomberb");
+  const dataDir = await getDataDir() ?? join(process.env.HOME || homedir(), ".gloomberb");
   if (!existsSync(dataDir)) {
     mkdirSync(dataDir, { recursive: true });
   }

package/src/renderers/electrobun/view/cli-pane-shot-entry.tsx

@@ -261,6 +261,7 @@ function createRuntime(payload: CliPaneShotPayload): PluginRuntimeAccess {
     switchPanel: () => {},
     openCommandBar: () => {},
     showPane: () => {},
+    createPaneFromTemplate: () => {},
     hidePane: () => {},
     focusPane: () => {},
     openPaneSettings: () => {},

package/src/renderers/electrobun/view/data-table/dom.ts

@@ -19,7 +19,6 @@ export const CSS_TEXT_DIM = "var(--gloom-text-dim)";
 export const CSS_TEXT_BRIGHT = "var(--gloom-text-bright)";
 export const CSS_SELECTED = "var(--gloom-selected)";
 export const CSS_SELECTED_TEXT = "var(--gloom-selected-text)";
-export const CSS_HOVER_BG = "var(--gloom-hover-bg)";
 
 function hasAttribute(attributes: unknown, flag: number): boolean {
   return typeof attributes === "number" && (attributes & flag) !== 0;

package/src/renderers/electrobun/view/host/mouse.ts

@@ -90,17 +90,6 @@ export function callCellMouseHandler(handler: unknown, event: CellMouseEvent): v
   (handler as (event: unknown) => void)(event);
 }
 
-export function hasDirectMouseHandler(props: Record<string, unknown>): boolean {
-  return typeof props.onMouseDown === "function"
-    || typeof props.onMouseOver === "function"
-    || typeof props.onMouseUp === "function"
-    || typeof props.onMouseMove === "function"
-    || typeof props.onMouseOut === "function"
-    || typeof props.onMouseDrag === "function"
-    || typeof props.onMouseDragEnd === "function"
-    || typeof props.onMouseScroll === "function";
-}
-
 export function cellBoundsForElement(
   getElement: () => HTMLElement | null,
   getProps: () => Record<string, unknown>,

package/src/renderers/electrobun/view/http-fetch.ts

@@ -11,6 +11,8 @@ interface ElectrobunHttpFetchResponse {
   body: string;
 }
 
+const CLOUD_MARKET_HTTP_TIMEOUT_MS = 10_000;
+
 function normalizeHeaders(headers: HeadersInit | undefined): Record<string, string> {
   const normalized: Record<string, string> = {};
   if (!headers) return normalized;
@@ -75,7 +77,11 @@ async function electrobunHttpFetch(url: string, init?: RequestInit): Promise<Res
   return fetchResponse;
 }
 
-async function requestBackendHttpFetch(url: string, init?: RequestInit): Promise<ElectrobunHttpFetchResponse> {
+async function requestBackendHttpFetch(
+  url: string,
+  init?: RequestInit,
+  timeoutMs?: number,
+): Promise<ElectrobunHttpFetchResponse> {
   return backendRequest<ElectrobunHttpFetchResponse>("http.fetch", {
     url,
     init: {
@@ -83,6 +89,7 @@ async function requestBackendHttpFetch(url: string, init?: RequestInit): Promise
       headers: normalizeHeaders(init?.headers),
       body: await serializeBody(init?.body),
       redirect: init?.redirect,
+      timeoutMs,
     },
   });
 }
@@ -100,7 +107,13 @@ function createResponseHeaders(headers: Record<string, string>, setCookie: strin
 }
 
 async function electrobunCloudApiFetch(url: string, init?: RequestInit): Promise<Response> {
-  const response = await requestBackendHttpFetch(url, init);
+  if (init?.signal?.aborted) {
+    throw createAbortError();
+  }
+  const timeoutMs = new URL(url).pathname.startsWith("/market/")
+    ? CLOUD_MARKET_HTTP_TIMEOUT_MS
+    : undefined;
+  const response = await withAbort(requestBackendHttpFetch(url, init, timeoutMs), init?.signal);
 
   return {
     ok: response.status >= 200 && response.status < 300,

package/src/renderers/electrobun/view/remote/asset-data-client.ts

@@ -3,9 +3,11 @@ import type { NewsArticle, NewsQuery } from "../../../../news/types";
 import type { DataProvider, QuoteSubscriptionTarget } from "../../../../types/data-provider";
 import type { Quote, TickerFinancials } from "../../../../types/financials";
 import { backendRequest, getElectrobunBackendInitSnapshot, onCapabilityEvent } from "../backend-rpc";
+import { createCapabilityInvoker } from "./capability-invoker";
 
 const ASSET_DATA_CAPABILITY_ID = "asset-data.asset-data-router";
 const NEWS_CAPABILITY_ID = "news.core";
+const ASSET_DATA_REQUEST_TIMEOUT_MS = 115_000;
 
 export type RemoteAssetDataClient = DataProvider & {
   getNews(query: NewsQuery): Promise<NewsArticle[]>;
@@ -64,23 +66,12 @@ function hasRendererOperation(operations: Set<string> | null, operationId: strin
   return operations === null || operations.has(operationId);
 }
 
-function createCapabilityInvoker() {
-  const inFlightRequests = new Map<string, Promise<unknown>>();
-  return function invoke<T>(capabilityId: string, operationId: string, payload: unknown): Promise<T> {
-    const requestPayload = { capabilityId, operationId, payload };
-    const key = JSON.stringify(requestPayload);
-    const inFlight = inFlightRequests.get(key);
-    if (inFlight) return inFlight as Promise<T>;
-    const promise = backendRequest<T>("capability.invoke", requestPayload).finally(() => {
-      inFlightRequests.delete(key);
-    });
-    inFlightRequests.set(key, promise);
-    return promise;
-  };
-}
-
 export function createRemoteAssetDataClient(): RemoteAssetDataClient {
-  const invoke = createCapabilityInvoker();
+  const invoke = createCapabilityInvoker({
+    request: backendRequest,
+    shouldApplyDeadline: (capabilityId) => capabilityId === ASSET_DATA_CAPABILITY_ID,
+    timeoutMs: ASSET_DATA_REQUEST_TIMEOUT_MS,
+  });
   const assetDataOperations = getRendererOperationIds(ASSET_DATA_CAPABILITY_ID);
   const newsOperations = getRendererOperationIds(NEWS_CAPABILITY_ID);
   let nextSubscriptionId = 1;
@@ -93,7 +84,7 @@ export function createRemoteAssetDataClient(): RemoteAssetDataClient {
   let quoteBackendFlushTimer: ReturnType<typeof setTimeout> | null = null;
 
   const quoteTargetKey = (target: QuoteSubscriptionTarget) =>
-    `${target.symbol}:${target.exchange ?? ""}:${target.context?.brokerId ?? ""}:${target.context?.brokerInstanceId ?? ""}:${target.context?.instrument?.conId ?? target.context?.instrument?.localSymbol ?? ""}`;
+    `${target.symbol}:${target.exchange ?? ""}:${target.context?.brokerId ?? ""}:${target.context?.brokerInstanceId ?? ""}:${target.context?.instrument?.conId ?? target.context?.instrument?.localSymbol ?? target.context?.instrument?.symbol ?? ""}`;
 
   const scheduleQuoteBackendSubscriptionFlush = () => {
     if (quoteBackendFlushTimer) return;
@@ -156,7 +147,7 @@ export function createRemoteAssetDataClient(): RemoteAssetDataClient {
       if (!hasRendererOperation(assetDataOperations, "subscribeQuotes")) return () => {};
       const uniqueTargets = [...new Map(
         targets.map((target) => [
-          `${target.symbol}:${target.exchange ?? ""}:${target.context?.brokerId ?? ""}:${target.context?.brokerInstanceId ?? ""}`,
+          quoteTargetKey(target),
           target,
         ] as const),
       ).values()];

package/src/renderers/electrobun/view/remote/capability-invoker.test.ts

@@ -0,0 +1,50 @@
+import { describe, expect, test } from "bun:test";
+import { createCapabilityInvoker } from "./capability-invoker";
+
+describe("createCapabilityInvoker", () => {
+  test("keeps timed-out calls deduped until the raw backend request settles", async () => {
+    let requestCount = 0;
+    const rawResolvers: Array<(value: unknown) => void> = [];
+    const invoke = createCapabilityInvoker({
+      request: <T>() => {
+        requestCount += 1;
+        return new Promise<T>((resolve) => {
+          rawResolvers.push((value) => resolve(value as T));
+        });
+      },
+      shouldApplyDeadline: (capabilityId) => capabilityId.startsWith("asset-data."),
+      timeoutMs: 10,
+    });
+    const payload = { ticker: "AAPL", exchange: "NASDAQ" };
+
+    const first = invoke("asset-data.asset-data-router", "getQuote", payload);
+    const duplicate = invoke("asset-data.asset-data-router", "getQuote", payload);
+    expect(duplicate).toBe(first);
+    expect(requestCount).toBe(1);
+    await expect(first).rejects.toThrow("Asset data request timed out after 10ms");
+
+    const retryWhileRawPending = invoke(
+      "asset-data.asset-data-router",
+      "getQuote",
+      payload,
+    );
+    expect(retryWhileRawPending).toBe(first);
+    await expect(retryWhileRawPending).rejects.toThrow(
+      "Asset data request timed out after 10ms",
+    );
+    expect(requestCount).toBe(1);
+
+    rawResolvers[0]?.({ price: 100 });
+    await Promise.resolve();
+    await Promise.resolve();
+
+    const retryAfterRawSettles = invoke(
+      "asset-data.asset-data-router",
+      "getQuote",
+      payload,
+    );
+    expect(requestCount).toBe(2);
+    rawResolvers[1]?.({ price: 101 });
+    await expect(retryAfterRawSettles).resolves.toEqual({ price: 101 });
+  });
+});

package/src/renderers/electrobun/view/remote/capability-invoker.ts

@@ -0,0 +1,36 @@
+import { withDeadline } from "../../../../utils/async-deadline";
+
+type CapabilityRequest = <T>(method: string, payload: unknown) => Promise<T>;
+
+export function createCapabilityInvoker(options: {
+  request: CapabilityRequest;
+  shouldApplyDeadline(capabilityId: string): boolean;
+  timeoutMs: number;
+}) {
+  const inFlightRequests = new Map<string, Promise<unknown>>();
+
+  return function invoke<T>(capabilityId: string, operationId: string, payload: unknown): Promise<T> {
+    const requestPayload = { capabilityId, operationId, payload };
+    const key = JSON.stringify(requestPayload);
+    const inFlight = inFlightRequests.get(key);
+    if (inFlight) return inFlight as Promise<T>;
+
+    const request = options.request<T>("capability.invoke", requestPayload);
+    const boundedRequest = options.shouldApplyDeadline(capabilityId)
+      ? withDeadline(
+        request,
+        options.timeoutMs,
+        `Asset data request timed out after ${options.timeoutMs}ms: ${operationId}`,
+      )
+      : request;
+    inFlightRequests.set(key, boundedRequest);
+    void request.finally(() => {
+      if (inFlightRequests.get(key) === boundedRequest) {
+        inFlightRequests.delete(key);
+      }
+    }).catch(() => {
+      // The returned bounded request owns error delivery to the caller.
+    });
+    return boundedRequest;
+  };
+}