gloomberb 0.18.2 → 0.18.3

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

@@ -1,3 +1,5 @@
+import { readdir, rm } from "fs/promises";
+import { basename, dirname, join } from "path";
 import type Electrobun from "electrobun/bun";
 import type { UpdateStatusEntry } from "electrobun/bun";
 import type { UpdateChannel } from "../../../../types/config";
@@ -15,6 +17,20 @@ import {
   type GitHubReleaseListing,
 } from "../../../../updater/github-releases";
 import { stagedUpdateFitsChannel } from "../../../../updater/channel";
+import {
+  classifyUpdateError,
+  httpStatusFailureCode,
+  type UpdateFailure,
+  type UpdateFailureCode,
+} from "../../../../updater/failure";
+import {
+  forgetStagedUpdate,
+  noteUpdateApplying,
+  noteUpdateStaged,
+  reportUpdateFailure,
+  type UpdateInstallKind,
+} from "../../../../telemetry/update-failures";
+import { logFailure } from "../../../../utils/log-failure";
 import { compareSemver, isPrereleaseVersion } from "../../../../utils/semver";
 import { VERSION } from "../../../../version";
 
@@ -27,7 +43,14 @@ type ElectrobunUpdater = typeof Electrobun.Updater;
  */
 export type ElectrobunUpdaterApi = Pick<
   ElectrobunUpdater,
-  "checkForUpdate" | "downloadUpdate" | "applyUpdate" | "updateInfo" | "clearStatusHistory" | "onStatusChange" | "setUpdateSource"
+  | "checkForUpdate"
+  | "downloadUpdate"
+  | "applyUpdate"
+  | "updateInfo"
+  | "clearStatusHistory"
+  | "getStatusHistory"
+  | "onStatusChange"
+  | "setUpdateSource"
 > & {
   localInfo: Pick<ElectrobunUpdater["localInfo"], "channel" | "baseUrl">;
 };
@@ -37,12 +60,111 @@ type ListReleases = () => Promise<GitHubReleaseListing[]>;
 
 const NIGHTLY_RELEASE_WINDOW = 30;
 
+/** A step that failed for a reason known where it was thrown. */
+class DesktopUpdateError extends Error {
+  constructor(message: string, readonly code: UpdateFailureCode) {
+    super(message);
+    this.name = "DesktopUpdateError";
+  }
+}
+
+/** `<app>.previous` and `<app>.previous-<suffix>`: what an install moves the old app to. */
+function isUpdateAside(entry: string, appName: string): boolean {
+  if (!entry.startsWith(`${appName}.previous`)) return false;
+  const rest = entry.slice(appName.length + ".previous".length);
+  return rest === "" || /^-[0-9a-z]+(?:-\d+)?$/.test(rest);
+}
+
+/**
+ * Removes the copies of the app an install moved aside and could not remove
+ * then (the Electrobun patch's `replaceAppBundle`), from beside the app this
+ * process runs from: starting from it means the install that left them worked.
+ * macOS keeps the app in its bundle, Linux in `<app data>/app` (`bin/bun`
+ * inside it); Windows installs through its own script and leaves none.
+ * Resolves to the paths it removed.
+ */
+export async function removeUpdateAsides(
+  execPath: string = process.execPath,
+  platform: string = process.platform,
+): Promise<string[]> {
+  const app = platform === "darwin"
+    ? /^(.*?\.app)\/Contents\/MacOS\/[^/]+$/.exec(execPath)?.[1]
+    : platform === "linux" && basename(dirname(execPath)) === "bin" ? dirname(dirname(execPath)) : undefined;
+  if (!app) return [];
+  const folder = dirname(app);
+  const removed: string[] = [];
+  for (const entry of await readdir(folder).catch(() => [] as string[])) {
+    if (!isUpdateAside(entry, basename(app))) continue;
+    const path = join(folder, entry);
+    // One that still cannot be removed (another user's) is tried again at the next start.
+    const done = await rm(path, { recursive: true, force: true }).then(() => true, logFailure("desktop-update", "Could not remove an old copy of the app", false));
+    if (done) removed.push(path);
+  }
+  return removed;
+}
+
+/**
+ * Where the running app sits, for update failure reports and for what an
+ * install that cannot replace it means. Electrobun replaces the macOS bundle
+ * the app runs from; on Windows and Linux it always installs into its own
+ * folder under the user's app data.
+ */
+export function detectDesktopInstallKind(
+  execPath: string = process.execPath,
+  platform: string = process.platform,
+  homeDir: string = process.env.HOME ?? "",
+): UpdateInstallKind {
+  if (platform !== "darwin") return platform === "win32" || platform === "linux" ? "desktop-app-data" : "unknown";
+  const bundle = /^(.*?\.app)\/Contents\//.exec(execPath)?.[1];
+  if (!bundle) return "unknown";
+  if (bundle.includes("/AppTranslocation/")) return "desktop-translocated";
+  if (bundle.startsWith("/Volumes/")) return "desktop-volume";
+  if (bundle.startsWith("/Applications/") || (homeDir && bundle.startsWith(`${homeDir}/Applications/`))) return "desktop-applications";
+  return "desktop-elsewhere";
+}
+
+/**
+ * On macOS a bundle that cannot be replaced where it runs (a disk image, the
+ * read-only copy App Translocation runs, another volume) is fixed by moving
+ * the app to Applications, which is what the header then says. Anywhere else
+ * a move across disks keeps its own reason: from Applications, moving the app
+ * again would not help.
+ */
+function installFailureCode(code: UpdateFailureCode, installKind: UpdateInstallKind): UpdateFailureCode {
+  const movable = installKind === "desktop-translocated" || installKind === "desktop-volume";
+  if (movable && (code === "permission_denied" || code === "read_only" || code === "wrong_location" || code === "cross_device")) return "wrong_location";
+  return code;
+}
+
+/**
+ * Why Electrobun's check failed. It returns one message for every failure, so
+ * the status it emitted just before says whether the server answered (with
+ * which status) or could not be reached.
+ */
+function checkFailureCode(error: string, history: UpdateStatusEntry[]): UpdateFailureCode {
+  const last = history.at(-1);
+  const status = last?.status === "error" ? /HTTP (\d{3})/.exec(last.message)?.[1] : undefined;
+  if (status) return httpStatusFailureCode(Number(status));
+  if (/Invalid update\.json/i.test(error)) return "bad_response";
+  const code = classifyUpdateError(error);
+  // "Failed to fetch update info" with no status before it: the request itself threw.
+  return code === "unknown" ? "offline" : code;
+}
+
+/** Why a download that Electrobun returned from did not leave an update ready. */
+function downloadFailureCode(error: string, lastErrorStatus: UpdateStatusEntry | null): UpdateFailure {
+  if (/zstd/i.test(error)) return { phase: "verify", code: "corrupt" };
+  if (lastErrorStatus?.message.startsWith("Failed to download:")) return { phase: "download", code: "http_error" };
+  const code = classifyUpdateError(error);
+  return { phase: "download", code: code === "unknown" ? "interrupted" : code };
+}
+
 async function listGitHubReleases(): Promise<GitHubReleaseListing[]> {
   const response = await fetch(`${GITHUB_RELEASES_API_URL}?per_page=${NIGHTLY_RELEASE_WINDOW}`, {
     headers: { Accept: "application/vnd.github+json" },
     signal: AbortSignal.timeout(10_000),
   });
-  if (!response.ok) throw new Error(`GitHub returned ${response.status}`);
+  if (!response.ok) throw new DesktopUpdateError(`GitHub returned ${response.status}`, httpStatusFailureCode(response.status));
   const data: unknown = await response.json();
   if (!Array.isArray(data)) throw new Error("GitHub returned an unexpected releases payload");
   return data as GitHubReleaseListing[];
@@ -88,6 +210,12 @@ function hasDesktopManifest(release: GitHubReleaseListing): boolean {
   return release.assets?.some((asset) => asset.name === manifest) === true;
 }
 
+/**
+ * The progress an Electrobun status means. An `error` status is left to the
+ * caller: during a download Electrobun emits some it recovers from (a patch
+ * that does not apply falls back to the full download), so only the outcome
+ * says whether the download failed.
+ */
 function mapDesktopUpdateStatus(entry: UpdateStatusEntry): UpdateProgress | null {
   const progress = entry.details?.progress;
   switch (entry.status) {
@@ -120,11 +248,6 @@ function mapDesktopUpdateStatus(entry: UpdateStatusEntry): UpdateProgress | null
     // once `updateInfo().updateReady` confirms it.
     case "complete":
       return { phase: "done", message: "Update installed, restarting..." };
-    case "error":
-      return {
-        phase: "error",
-        error: entry.details?.errorMessage || entry.message,
-      };
     default:
       return null;
   }
@@ -133,9 +256,12 @@ function mapDesktopUpdateStatus(entry: UpdateStatusEntry): UpdateProgress | null
 export function createElectrobunDesktopUpdater(
   updater: ElectrobunUpdaterApi,
   {
+    installKind = detectDesktopInstallKind(),
     listReleases = listGitHubReleases,
     runningVersion = VERSION,
   }: {
+    /** Where the app runs from, which an install that cannot replace it is blamed on. */
+    installKind?: UpdateInstallKind;
     listReleases?: ListReleases;
     /** The version of the installed app, which a download checks as. */
     runningVersion?: string;
@@ -152,6 +278,15 @@ export function createElectrobunDesktopUpdater(
   /** An apply is under way, or finished and the app is quitting. */
   let applyInProgress = false;
 
+  /** The error progress for a failed step, reported to error tracking on the way. */
+  function failed(failure: UpdateFailure, error: string, release?: { version?: string; channel?: UpdateChannel } | null): UpdateProgress {
+    reportUpdateFailure(failure, {
+      targetVersion: release?.version,
+      channel: release?.channel === "nightly" ? "nightly" : "stable",
+    });
+    return { phase: "error", error, failure };
+  }
+
   /**
    * Forgets a downloaded update `updateChannel` does not allow: a nightly
    * build staged before the switch back to stable. Electrobun's own ready
@@ -159,7 +294,10 @@ export function createElectrobunDesktopUpdater(
    * a restart cannot install it, and its files go with the next download.
    */
   function dropStagedMisfit(updateChannel: UpdateChannel): void {
-    if (readyRelease && !applyInProgress && !stagedUpdateFitsChannel(readyRelease, updateChannel)) readyRelease = null;
+    if (readyRelease && !applyInProgress && !stagedUpdateFitsChannel(readyRelease, updateChannel)) {
+      readyRelease = null;
+      forgetStagedUpdate();
+    }
   }
 
   async function releaseInfo(updateInfo: { version?: string; hash?: string }, currentVersion: string): Promise<ReleaseInfo> {
@@ -177,6 +315,13 @@ export function createElectrobunDesktopUpdater(
     };
   }
 
+  /** Electrobun's check, with the failure it ended in named. */
+  async function checkElectrobun(): Promise<Awaited<ReturnType<ElectrobunUpdaterApi["checkForUpdate"]>> | { error: string; code: UpdateFailureCode }> {
+    const info = await updater.checkForUpdate();
+    if (!info.error) return info;
+    return { error: info.error, code: checkFailureCode(info.error, updater.getStatusHistory()) };
+  }
+
   /**
    * Nightly: the highest version among the newest releases that has this
    * platform's desktop manifest, nightly or stable, fetched from that release's
@@ -192,8 +337,8 @@ export function createElectrobunDesktopUpdater(
     const baseUrl = githubReleaseDownloadBaseUrl(target.tag_name);
     updater.setUpdateSource({ channel: filesChannel, baseUrl });
 
-    const info = await updater.checkForUpdate();
-    if (info.error) return { kind: "error", error: info.error };
+    const info = await checkElectrobun();
+    if ("code" in info) throw new DesktopUpdateError(info.error, info.code);
     // The same build as the one installed.
     if (!info.updateAvailable) return { kind: "current" };
 
@@ -210,7 +355,11 @@ export function createElectrobunDesktopUpdater(
     };
   }
 
-  async function check(currentVersion: string, updateChannel: UpdateChannel = "stable"): Promise<UpdateCheckResult> {
+  /**
+   * The check, without reporting: a download runs it first and reports what
+   * went wrong itself.
+   */
+  async function checkQuietly(currentVersion: string, updateChannel: UpdateChannel): Promise<UpdateCheckResult> {
     dropStagedMisfit(updateChannel);
     // A downloaded update the channel still allows stays the answer until the
     // user restarts into it, and asking Electrobun again would discard its
@@ -229,9 +378,9 @@ export function createElectrobunDesktopUpdater(
 
       // Stable is the release version.json names, as it always was.
       updater.setUpdateSource(null);
-      const info = await updater.checkForUpdate();
-      if (info.error) {
-        return { kind: "error", error: info.error };
+      const info = await checkElectrobun();
+      if ("code" in info) {
+        return { kind: "error", error: info.error, failure: { phase: "check", code: info.code } };
       }
       if (!info.updateAvailable) {
         return { kind: "current" };
@@ -247,13 +396,21 @@ export function createElectrobunDesktopUpdater(
         release: await releaseInfo(info, currentVersion),
       };
     } catch (error) {
+      const code = error instanceof DesktopUpdateError ? error.code : classifyUpdateError(error);
       return {
         kind: "error",
         error: error instanceof Error ? error.message : "Desktop update check failed",
+        failure: { phase: "check", code },
       };
     }
   }
 
+  async function check(currentVersion: string, updateChannel: UpdateChannel = "stable"): Promise<UpdateCheckResult> {
+    const result = await checkQuietly(currentVersion, updateChannel);
+    if (result.kind === "error" && result.failure) reportUpdateFailure(result.failure, { channel: updateChannel });
+    return result;
+  }
+
   async function download(
     release: Pick<ReleaseInfo, "channel">,
     onProgress: (progress: UpdateProgress) => void,
@@ -277,17 +434,25 @@ export function createElectrobunDesktopUpdater(
     }
 
     downloadInProgress = true;
+    /** The last error Electrobun emitted on the way, which may or may not have ended the download. */
+    let lastErrorStatus: UpdateStatusEntry | null = null;
+    /** The release the download is for, once the check has found it. */
+    let target: ReleaseInfo | null = null;
     updater.clearStatusHistory();
     updater.onStatusChange((entry) => {
+      if (entry.status === "error") {
+        lastErrorStatus = entry;
+        return;
+      }
       const progress = mapDesktopUpdateStatus(entry);
       if (progress) onProgress(progress);
     });
 
     try {
       onProgress({ phase: "downloading", percent: 0 });
-      const result = await check(runningVersion, updateChannel);
+      const result = await checkQuietly(runningVersion, updateChannel);
       if (result.kind === "error") {
-        onProgress({ phase: "error", error: result.error });
+        onProgress(failed(result.failure ?? { phase: "check", code: "unknown" }, result.error, { channel: updateChannel }));
         return;
       }
       if (result.kind !== "available") {
@@ -297,27 +462,31 @@ export function createElectrobunDesktopUpdater(
         });
         return;
       }
+      target = result.release;
 
       await updater.downloadUpdate();
       const updateInfo = updater.updateInfo();
       if (updateInfo?.error) {
-        onProgress({ phase: "error", error: updateInfo.error });
+        onProgress(failed(downloadFailureCode(updateInfo.error, lastErrorStatus), updateInfo.error, result.release));
         return;
       }
       if (!updateInfo?.updateReady) {
-        onProgress({ phase: "error", error: "Desktop update did not finish downloading." });
+        onProgress(failed({ phase: "download", code: "interrupted" }, "Desktop update did not finish downloading.", result.release));
         return;
       }
 
       // Downloaded, not installed: applying relaunches the app, and that waits
       // for the user's explicit request (`apply`).
       readyRelease = result.release;
+      noteUpdateStaged(result.release.version, updateChannel);
       onProgress({ phase: "ready", canRestart: true });
     } catch (error) {
-      onProgress({
-        phase: "error",
-        error: error instanceof Error ? error.message : "Desktop update failed",
-      });
+      const code = classifyUpdateError(error);
+      onProgress(failed(
+        { phase: "download", code: code === "unknown" ? "interrupted" : code },
+        error instanceof Error ? error.message : "Desktop update failed",
+        { version: target?.version, channel: updateChannel },
+      ));
     } finally {
       downloadInProgress = false;
       updater.onStatusChange(null);
@@ -327,11 +496,13 @@ export function createElectrobunDesktopUpdater(
   async function apply(onProgress: (progress: UpdateProgress) => void): Promise<void> {
     if (applyInProgress || downloadInProgress) return;
     if (!readyRelease || !updater.updateInfo()?.updateReady) {
+      const missing = readyRelease;
       readyRelease = null;
-      onProgress({ phase: "error", error: "The downloaded update is no longer available." });
+      onProgress(failed({ phase: "apply", code: "staged_missing" }, "The downloaded update is no longer available.", missing));
       return;
     }
 
+    const target = readyRelease;
     applyInProgress = true;
     let relaunching = false;
     let reportedError = false;
@@ -339,7 +510,19 @@ export function createElectrobunDesktopUpdater(
       if (progress.phase === "error") reportedError = true;
       onProgress(progress);
     };
+    const installFailed = (error: unknown, message: string) => {
+      // Electrobun names the system error in its message ("Failed to replace app: EACCES: ...").
+      const code = installFailureCode(classifyUpdateError(error), installKind);
+      report(failed({ phase: relaunching ? "relaunch" : "apply", code }, message, target));
+    };
+    // Kept before Electrobun quits the app, so the next launch can tell whether it took.
+    noteUpdateApplying(target.version, target.channel === "nightly" ? "nightly" : "stable");
     updater.onStatusChange((entry) => {
+      if (entry.status === "error") {
+        const message = entry.details?.errorMessage || entry.message;
+        installFailed(message, message);
+        return;
+      }
       if (entry.status === "launching-new-version" || entry.status === "complete") relaunching = true;
       const progress = mapDesktopUpdateStatus(entry);
       if (progress) report(progress);
@@ -348,16 +531,13 @@ export function createElectrobunDesktopUpdater(
     try {
       report({ phase: "replacing" });
       await updater.applyUpdate();
-      // Electrobun returns without a status when it cannot install, for example
-      // when a newer release replaced the one that was downloaded.
+      // Electrobun returns without a status when it finds nothing to install:
+      // the downloaded files are gone, or hold no app.
       if (!relaunching && !reportedError) {
-        report({ phase: "error", error: "Desktop update could not be installed." });
+        report(failed({ phase: "apply", code: "staged_missing" }, "Desktop update could not be installed.", target));
       }
     } catch (error) {
-      report({
-        phase: "error",
-        error: error instanceof Error ? error.message : "Desktop update failed",
-      });
+      installFailed(error, error instanceof Error ? error.message : "Desktop update failed");
     } finally {
       updater.onStatusChange(null);
     }

package/src/renderers/electrobun/view/news-source.ts

@@ -1,12 +1,13 @@
 import { apiClient } from "../../../api-client";
 import { newsProvider, type NewsCapability } from "../../../capabilities";
 import { cloudNewsParams, mapCloudNewsArticle } from "../../../sources/gloomberb-cloud/news";
-import type { NewsArticle, NewsQuery } from "../../../types/news-source";
+import type { NewsArticle, NewsPage, NewsQuery } from "../../../news/types";
 
 interface BackendNews {
   id: string;
   name: string;
   getNews(query: NewsQuery): Promise<NewsArticle[]>;
+  getNewsPage(query: NewsQuery): Promise<NewsPage>;
 }
 
 type CloudNewsClient = Pick<typeof apiClient, "getCloudNews" | "getCloudNewsStory">;
@@ -33,7 +34,8 @@ export function createDesktopNewsSource(backend: BackendNews, client: CloudNewsC
             nextCursor: response.nextCursor ?? null,
           };
         } catch {
-          return { articles: await backend.getNews(query), nextCursor: null };
+          // The aggregate page keeps RSS failures beside any usable stories.
+          return backend.getNewsPage(query);
         }
       },
       fetchNewsStory: async (storyId) => mapCloudNewsArticle(await client.getCloudNewsStory(storyId)),

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

@@ -1,5 +1,5 @@
 import type { CapabilityManifest } from "../../../../capabilities";
-import type { NewsArticle, NewsQuery } from "../../../../news/types";
+import type { NewsArticle, NewsPage, NewsQuery } from "../../../../news/types";
 import type { DataProvider } from "../../../../types/data-provider";
 import type { TickerFinancials } from "../../../../types/financials";
 import { backendRequest, getElectrobunBackendInitSnapshot, subscribeBackendCapability } from "../backend-rpc";
@@ -14,6 +14,7 @@ const ASSET_DATA_REQUEST_TIMEOUT_MS = 115_000;
 
 export type RemoteAssetDataClient = DataProvider & {
   getNews(query: NewsQuery): Promise<NewsArticle[]>;
+  getNewsPage(query: NewsQuery): Promise<NewsPage>;
 };
 
 interface RemoteAssetDataClientBase {
@@ -21,6 +22,7 @@ interface RemoteAssetDataClientBase {
   name: string;
   getCachedFinancialsForTargets: NonNullable<DataProvider["getCachedFinancialsForTargets"]>;
   getNews(query: NewsQuery): Promise<NewsArticle[]>;
+  getNewsPage(query: NewsQuery): Promise<NewsPage>;
   subscribeQuotes: NonNullable<DataProvider["subscribeQuotes"]>;
 }
 
@@ -130,6 +132,11 @@ export function createRemoteAssetDataClient(): RemoteAssetDataClient {
         ? invoke<NewsArticle[]>(NEWS_CAPABILITY_ID, "fetchNews", { query })
         : Promise.resolve([])
     ),
+    getNewsPage: (query) => (
+      hasRendererOperation(newsOperations, "fetchNewsPage")
+        ? invoke<NewsPage>(NEWS_CAPABILITY_ID, "fetchNewsPage", { query })
+        : Promise.reject(new Error("News is unavailable."))
+    ),
     subscribeQuotes: (targets, onQuote) => {
       if (!hasRendererOperation(assetDataOperations, "subscribeQuotes")) return () => {};
       return quoteSubscriptions.subscribe(targets, onQuote);

package/src/renderers/opentui/start.tsx

@@ -37,6 +37,9 @@ import {
   readOrCreateInstallId,
 } from "../../telemetry/crash-reports-node";
 import { currentTelemetryConfig } from "../../telemetry/live-config";
+import { installUpdateFailureReporter } from "../../telemetry/update-failures";
+import { createNodeUpdateFailureHost } from "../../telemetry/update-failures-node";
+import { terminalInstallKind } from "../../updater";
 import { flushUsageCounts, installUsageCounter, usageCountsEnabled } from "../../telemetry/usage-counts";
 import { attentionCountsEnabled, installAttentionCounter } from "../../telemetry/attention-counts";
 import { starPromptEnvironmentAllows } from "../../app/star-prompt/model";
@@ -117,6 +120,10 @@ export async function startOpenTuiApp({ externalPlugins, cliLaunchRequest }: Sta
       surface: "terminal",
       getConfig: () => ({ dataDir: config.dataDir, telemetry: currentTelemetryConfig(config)?.telemetry }),
     }));
+    installUpdateFailureReporter(createNodeUpdateFailureHost({
+      installKind: terminalInstallKind(),
+      getDataDir: () => config.dataDir,
+    }));
     installUsageCounter({
       surface: "terminal",
       os: describeNodeOs(),

package/src/sources/gloomberb-cloud/index.ts

@@ -30,6 +30,7 @@ import { parseHistorySession } from "../../market-data/history-session";
 import { quoteMetadataFromQuote, quoteMetadataMatchesTarget } from "../../market-data/quotes/metadata";
 import type { InstrumentSearchResult } from "../../types/instrument";
 import type { TickerChanges } from "../../types/ticker-changes";
+import type { IssuerListings } from "../../types/issuer-listings";
 import {
   apiClient,
   type CloudAnalystResearchPayload,
@@ -718,6 +719,12 @@ export class GloomberbCloudProvider implements AssetDataProvider {
     return cloudTickerChangesBatch(symbols, options);
   }
 
+  async getIssuerListings(symbol: string, exchange = "", options: { signal?: AbortSignal } = {}): Promise<IssuerListings | null> {
+    const response = await apiClient.getCloudIssuerListings(symbol, exchange, options);
+    // "empty" is an answer: the service holds no company for the listing.
+    return response.status === "success" || response.status === "partial" ? response.data : null;
+  }
+
   async searchBatch(queries: string[], options: { limit?: number; signal?: AbortSignal } = {}): Promise<Map<string, InstrumentSearchResult[]> | null> {
     const answers = await cloudSearchBatch(queries, options);
     if (!answers) return null;

package/src/sources/provider-router/index.ts

@@ -26,6 +26,7 @@ import { mergeQuoteMetadata, quoteMetadataFromQuote, quoteMetadataMatchesTarget
 import type { NewsArticle, NewsQuery } from "../../news/types";
 import type { BrokerContractRef, InstrumentSearchResult } from "../../types/instrument";
 import type { TickerChanges } from "../../types/ticker-changes";
+import type { IssuerListings } from "../../types/issuer-listings";
 import type { TimeRange } from "../../time-series/range";
 import type { ChartResolutionSupport, ManualChartResolution } from "../../time-series/resolution";
 import { debugLog } from "../../utils/debug-log";
@@ -317,6 +318,21 @@ export class AssetDataRouter implements DataProvider {
     return null;
   }
 
+  /** The first source that holds the company's listings; one that fails is passed over. */
+  async getIssuerListings(symbol: string, exchange?: string, options?: { signal?: AbortSignal }): Promise<IssuerListings | null> {
+    for (const provider of this.providersInPriorityOrder()) {
+      if (!provider.getIssuerListings) continue;
+      try {
+        const listings = await provider.getIssuerListings(symbol, exchange, options);
+        if (listings) return listings;
+      } catch (error) {
+        if (options?.signal?.aborted) return null;
+        logFailure("sources.provider-router.index", "Issuer listings failed")(error);
+      }
+    }
+    return null;
+  }
+
   async getEarningsCalendar(symbols: string[], context?: MarketDataRequestContext) {
     return this.supplementalRoutes.getEarningsCalendar(symbols, context);
   }

package/src/telemetry/crash-reports.ts

@@ -5,6 +5,7 @@ import {
   type CrashReportKind,
   type CrashReportSurface,
   type CrashReportsPayload,
+  type UpdateFailureReport,
 } from "../api-client";
 import type { TelemetryConfig } from "../types/config";
 import { isSleepRpcTimeout } from "../utils/rpc-timeout-error";
@@ -68,6 +69,8 @@ export interface CrashReportContext {
   pane?: string;
   /** React's component stack for a render crash; appended to the stack. */
   componentStack?: string | null;
+  /** A failed update step (update-failures.ts), sent as it is: it holds no free text. */
+  update?: UpdateFailureReport;
 }
 
 interface PendingError {
@@ -167,6 +170,7 @@ function toReportError(error: unknown, context: CrashReportContext): PendingErro
       ...(stack ? { stack } : {}),
       ...(context.plugin ? { plugin: clip(context.plugin, MAX_LABEL_LENGTH) } : {}),
       ...(context.pane ? { pane: clip(context.pane, MAX_LABEL_LENGTH) } : {}),
+      ...(context.update ? { update: context.update } : {}),
     },
   };
 }

package/src/telemetry/update-failures-node.ts

@@ -0,0 +1,59 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import type { UpdateChannel } from "../types/config";
+import type {
+  UpdateAttempt,
+  UpdateFailureReporterHost,
+  UpdateInstallKind,
+  UpdateReportState,
+} from "./update-failures";
+
+/** Next to config.json: when each update failure was last reported, and the last update attempt. */
+const STATE_FILE = "update-reports.json";
+
+function readAttempt(value: unknown): UpdateAttempt | undefined {
+  if (!value || typeof value !== "object") return undefined;
+  const { from, to, channel, at } = value as Record<string, unknown>;
+  if (typeof from !== "string" || typeof to !== "string" || typeof at !== "number" || !Number.isFinite(at)) return undefined;
+  return { from, to, channel: (channel === "nightly" ? "nightly" : "stable") satisfies UpdateChannel, at };
+}
+
+/** The saved state, keeping only entries of the right shape. */
+function parseUpdateReportState(text: string): UpdateReportState {
+  const parsed: unknown = JSON.parse(text);
+  const record = parsed && typeof parsed === "object" ? parsed as Record<string, unknown> : {};
+  const sent: Record<string, number> = {};
+  if (record.sent && typeof record.sent === "object") {
+    for (const [key, at] of Object.entries(record.sent as Record<string, unknown>)) {
+      if (typeof at === "number" && Number.isFinite(at)) sent[key] = at;
+    }
+  }
+  const staged = readAttempt(record.staged);
+  const applying = readAttempt(record.applying);
+  return { sent, ...(staged ? { staged } : {}), ...(applying ? { applying } : {}) };
+}
+
+/** The update failure reporter for a Bun process (the terminal app, the desktop app's main process). */
+export function createNodeUpdateFailureHost(options: {
+  installKind: UpdateInstallKind;
+  /** The profile's data folder, or null before the config is loaded. */
+  getDataDir(): string | null;
+}): UpdateFailureReporterHost {
+  return {
+    installKind: options.installKind,
+    platform: process.platform,
+    arch: process.arch,
+    load: () => {
+      const dir = options.getDataDir();
+      const path = dir ? join(dir, STATE_FILE) : null;
+      if (!path || !existsSync(path)) return { sent: {} };
+      return parseUpdateReportState(readFileSync(path, "utf-8"));
+    },
+    save: (state) => {
+      const dir = options.getDataDir();
+      if (!dir) return;
+      mkdirSync(dir, { recursive: true });
+      writeFileSync(join(dir, STATE_FILE), JSON.stringify(state), "utf-8");
+    },
+  };
+}