@gloom-sh/terminal 0.19.1 → 0.19.2

package/src/plugins/builtin/volatility/model.ts

@@ -30,6 +30,11 @@ export interface VolatilityHistoryInput {
   stale?: boolean;
   error?: string | null;
   fetchedAt?: number | null;
+  /**
+   * When the copy shown was saved, when a failed refresh left it answering:
+   * the pane's footer says "saved copy from …" instead of the failure.
+   */
+  savedAt?: number | null;
 }
 export interface VolatilitySeriesInput {
   observations: CloudFredObservationPayload[];
@@ -37,6 +42,8 @@ export interface VolatilitySeriesInput {
   stale?: boolean;
   error?: string | null;
   fetchedAt?: number | null;
+  /** As `VolatilityHistoryInput.savedAt`. */
+  savedAt?: number | null;
 }
 export interface VolatilityInputs {
   history?: Partial<Record<VolatilityIndexId, VolatilityHistoryInput>>;
@@ -131,6 +138,8 @@ export interface VolatilityBoardRow {
   status: "available" | "limited" | "unavailable";
   stale: boolean;
   error: string | null;
+  /** When the copy shown was saved, when a failed refresh left it answering. */
+  savedAt?: number;
   warnings: string[];
 }
 export interface VolatilityData {
@@ -233,8 +242,9 @@ function fredHistory(inputs: VolatilityInputs["fred"]): FredVolatilityHistory {
     const input = inputs?.[definition.seriesId];
     const normalized = normalizeHistory(input?.observations ?? [], true);
     warnings.push(...normalized.warnings.map((warning) => `${definition.seriesId}: ${warning}`));
-    if (input?.error) warnings.push(`${definition.seriesId}: ${input.error}`);
-    if (input?.stale) warnings.push(`${definition.seriesId}: cached source is stale`);
+    // A saved copy is dated in the footer; its failed refresh is not repeated here.
+    if (input?.error && input.savedAt == null) warnings.push(`${definition.seriesId}: ${input.error}`);
+    if (input?.stale && input.savedAt == null) warnings.push(`${definition.seriesId}: cached source is stale`);
     const latest = normalized.history.at(-1);
     return { ...definition, title: input?.info?.title ?? definition.label, value: latest?.value ?? null,
       date: latest?.date ?? null, history: normalized.history,
@@ -300,15 +310,16 @@ function boardRow(definition: typeof VOLATILITY_INDICES[number], input: Volatili
   if (latest && latest.date !== normalized.rows.at(-1)?.date) warnings.push("Latest supplied close unavailable; showing last valid observation");
   if (latest && !adjacent) warnings.push("1D change unavailable: previous daily close missing or too far apart");
   if (latest && !broadCoverage) warnings.push(`1Y percentile unavailable: ${history.length} observations across ${coverageDays} days`);
-  if (input?.stale) warnings.push("Cached daily history is stale");
-  if (input?.error) warnings.push(input.error);
+  // A saved copy is dated in the footer; its failed refresh is not repeated here.
+  if (input?.stale && input.savedAt == null) warnings.push("Cached daily history is stale");
+  if (input?.error && input.savedAt == null) warnings.push(input.error);
   return { ...definition, unit: "index points", value: latest?.value ?? null, date: latest?.date ?? null,
     source: input?.source ?? null, previousDate: previous?.date ?? null, change1d,
     change1dPercent: change1d != null ? change1d / previous!.value! * 100 : null,
     percentile1y, sampleSize: history.length, coverageDays, history,
     missingDates: normalized.rows.filter((row) => row.value == null && Date.parse(row.date) > cutoff).map((row) => row.date),
     status: !latest ? "unavailable" : warnings.length > 0 ? "limited" : "available",
-    stale: input?.stale ?? false, error: input?.error ?? null, warnings };
+    stale: input?.stale ?? false, error: input?.error ?? null, ...(input?.savedAt != null ? { savedAt: input.savedAt } : {}), warnings };
 }
 function alignedCurve(board: readonly VolatilityBoardRow[], fred: FredVolatilityHistory, term: VolatilityTermHistory): VolatilityCurve {
   const rows = VOLATILITY_CURVE_INDICES.map((definition) => board.find((row) => row.id === definition.id)!);
@@ -337,7 +348,7 @@ function alignedCurve(board: readonly VolatilityBoardRow[], fred: FredVolatility
   const spot = points[1]!.value, threeMonth = points[2]!.value;
   const warnings = points.flatMap((point, index) => [
     ...(point.value == null ? [`${point.label}: no close aligned to ${date ?? "a common date"}`] : []),
-    ...(point.value != null && rows[index]!.stale ? [`${point.label}: aligned close is from stale cached history`] : []),
+    ...(point.value != null && rows[index]!.stale && rows[index]!.savedAt == null ? [`${point.label}: aligned close is from stale cached history`] : []),
   ]);
   const ratio = spot != null && threeMonth != null ? threeMonth / spot : null;
   const context = ratioPercentile(term, ratio, date);

package/src/plugins/builtin/volatility/pane.tsx

@@ -2,6 +2,8 @@ import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { ChartTableHeader, CurveSurface, curveGhostColors, DataTableView, formatPercentAxis, PaneStatusBody, useChartTableSelection,
   usePaneFooter, usePaneNoticeFooter, usePaneTabs, type DataTableColumn, type StatItem } from "../../../components";
 import { curveStrip, curveSurfaceMinRows } from "../../../components/chart/curve";
+import { savedCopyFooterInfo } from "../../../components/layout/pane/footer";
+import { STALE_SEGMENT } from "../../../components/layout/pane/status-footer";
 import { dropColumnsToFit } from "../../../components/ui/table-layout";
 import { useAsyncResource } from "../../../react/async-resource";
 import { usePaneRefreshKey } from "../../../components/data-table/table-pane";
@@ -170,13 +172,15 @@ export function VolatilityPane({ focused, width, height }: PaneProps) {
   const observationBasis = intraday ? "intraday" : sparse ? "observation" : settled ? "close" : DAY_SO_FAR_TEXT;
   usePaneFooter("volatility", () => ({ info: [
     ...(resource.loading ? [{ id: "loading", parts: [{ text: "loading volatility", tone: "muted" as const }] }] : []),
-    ...(result?.stale ? [{ id: "stale", parts: [{ text: "stale", tone: "warning" as const }] }] : []),
+    // A saved copy answering a failed refresh says when it was saved; other stale closes say only that.
+    ...savedCopyFooterInfo([result?.savedAt]),
+    ...(result?.stale && result.savedAt == null ? [STALE_SEGMENT] : []),
     // One fact, "close 2026-09-25": the basis and its date read as one segment.
     ...(data || asOf ? [{ id: "basis", parts: [
       ...(data ? [{ text: observationBasis, tone: "muted" as const }] : []),
       ...(asOf ? [{ text: observationTime ? `${observationTime.slice(0, 16).replace("T", " ")} UTC` : asOf, tone: "muted" as const }] : []),
     ] }] : []),
-  ], hints: [{ id: "view", key: "v", label: "iew", onPress: cycleTab }] }), [resource.loading, result?.stale, data, asOf, observationTime, observationBasis, cycleTab]);
+  ], hints: [{ id: "view", key: "v", label: "iew", onPress: cycleTab }] }), [resource.loading, result?.stale, result?.savedAt, data, asOf, observationTime, observationBasis, cycleTab]);
   const { strip: tabStrip, rows: tabRows } = usePaneTabs({ tabs: TABS, activeValue: tab, onSelect: setTab, focused, dense: true });
   const contentHeight = Math.max(5, height - tabRows);
   // The board needs only its rows; the selected index history takes the rest.

package/src/plugins/builtin/volatility/series.ts

@@ -105,11 +105,12 @@ export const VOLATILITY_SERIES: readonly SeriesDefinition[] = [
     tags: ["term structure", "contango", "backwardation", "VIX"],
     description: "VIX 3M over VIX on each date both closed, from Cboe's daily closes and FRED's before them; above 1 is contango.",
     load: async ({ start, signal }) => {
-      const { term, warning } = await loadVolatilityTermHistory({ ...(start ? { start } : {}), ...(signal ? { signal } : {}) });
+      const { term, warning, savedAt } = await loadVolatilityTermHistory({ ...(start ? { start } : {}), ...(signal ? { signal } : {}) });
       const attribution = termAttribution(term);
       return {
         points: term.ratioHistory.map((point) => ({ date: point.date, value: point.value })),
         ...(warning ? { warning } : {}),
+        ...(savedAt != null ? { savedAt } : {}),
         ...(attribution ? { attribution } : {}),
       };
     },

package/src/plugins/builtin/yield-curve/client.ts

@@ -1,7 +1,6 @@
 import { apiClient } from "../../../api-client";
 import type { SwapCurvePayload, SwapTenor } from "../../../api-client/swap-curve";
-import { isPermanentClientError } from "../../../api-client/errors";
-import { createPluginCache, type PluginCacheResult } from "../../../data/plugin-cache";
+import { createPluginCache, savedCopyForTransientFailure, type PluginCacheResult } from "../../../data/plugin-cache";
 import { cachedCloudResource, loadCloudResource, unavailableOnServer } from "../shared/cloud-resource";
 import { validateSwapCurve } from "./swaps-model";
 import { loadCurveData, type CurveData, type CurveId } from "./curves";
@@ -52,12 +51,11 @@ export interface SavedCopyAnswer<T> {
 const curveKey = (curve: CurveId, requestedDate: string) => `${curve}:${requestedDate || "latest"}`;
 /**
  * A copy is the saved one by where it came from, whatever its failure said. A
- * refusal asking again will not change (access denied, an unknown curve) is
- * said rather than covered by the copy, as `loadCloudResource` does.
+ * refusal (access denied, an unknown curve) or a reply that fails validation
+ * is said rather than covered by the copy, as `loadCloudResource` does.
  */
 function answer<T>(result: PluginCacheResult<T>): SavedCopyAnswer<T> {
-  const saved = result.source === "stale-fallback";
-  if (saved && isPermanentClientError(result.error)) throw result.error;
+  const saved = savedCopyForTransientFailure(result).source === "stale-fallback";
   return { data: result.data, savedAt: saved ? result.fetchedAt : null };
 }
 

package/src/plugins/installer.ts

@@ -141,7 +141,13 @@ function run(
 /** Whether a `git` command is on the PATH; plugins from GitHub need one to install or update. */
 export function gitInstalled(): boolean {
   if (typeof Bun !== "undefined") return Bun.which("git") !== null;
-  return gitSucceeds(["--version"], process.cwd());
+  try {
+    execFileSync("git", ["--version"], { stdio: "ignore" });
+    return true;
+  } catch {
+    // Intentional ignore: a git that does not start is the answer this asks for.
+    return false;
+  }
 }
 
 /** What a plugin install says when there is no git to run: what to install, then to try again. */
@@ -171,14 +177,9 @@ async function git(args: string[], cwd: string, quiet: boolean, failure: string)
   return result.stdout.trim();
 }
 
-function isOnBranch(dir: string): boolean {
-  try {
-    execFileSync("git", ["symbolic-ref", "-q", "HEAD"], { cwd: dir, stdio: "ignore" });
-    return true;
-  } catch {
-    // Intentional ignore: Detached HEAD is expected after a pinned install.
-    return false;
-  }
+/** False on a detached HEAD, which a pinned install leaves. */
+function isOnBranch(dir: string): Promise<boolean> {
+  return gitSucceedsAsync(["symbolic-ref", "-q", "HEAD"], dir);
 }
 
 function pinMatches(commit: string | null, expected: string | undefined): boolean {
@@ -208,27 +209,27 @@ async function checkoutCommit(targetDir: string, commit: string, quiet: boolean)
   await git(["checkout", "--detach", "--force", commit], targetDir, quiet, `Could not check out ${commit.slice(0, 7)}`);
 }
 
-function gitSucceeds(args: string[], cwd: string): boolean {
-  try {
-    execFileSync("git", args, { cwd, stdio: "ignore" });
-    return true;
-  } catch {
-    // Intentional ignore: Non-ancestor and shallow histories use package versions and commit dates instead.
-    return false;
-  }
+
+/*
+ * The update path runs in the app (the terminal, the desktop's Bun process),
+ * where a sync git call holds the thread for the whole process start: tens of
+ * milliseconds each on Windows, several per plugin. These never block it.
+ */
+async function gitSucceedsAsync(args: string[], cwd: string): Promise<boolean> {
+  const result = await run("git", args, cwd, { stdout: "pipe", stderr: "pipe" })
+    .catch(logFailure("plugin-installer", "Could not run git", null));
+  return result?.code === 0;
 }
 
-function gitOutput(args: string[], cwd: string): string | null {
-  try {
-    return execFileSync("git", args, { cwd, stdio: ["ignore", "pipe", "ignore"] }).toString("utf-8").trim();
-  } catch {
-    // Intentional ignore: Shallow or manifest-free checkouts may lack historical metadata.
-    return null;
-  }
+/** Null when git fails: shallow or manifest-free checkouts may lack historical metadata. */
+async function gitOutputAsync(args: string[], cwd: string): Promise<string | null> {
+  const result = await run("git", args, cwd, { stdout: "pipe", stderr: "pipe" })
+    .catch(logFailure("plugin-installer", "Could not run git", null));
+  return result?.code === 0 ? result.stdout.trim() : null;
 }
 
-function versionAt(dir: string, commit: string): string | null {
-  const text = gitOutput(["show", `${commit}:package.json`], dir);
+async function versionAt(dir: string, commit: string): Promise<string | null> {
+  const text = await gitOutputAsync(["show", `${commit}:package.json`], dir);
   if (!text) return null;
   try {
     const version = JSON.parse(text).version;
@@ -247,15 +248,15 @@ function versionAt(dir: string, commit: string): string | null {
  * it; otherwise the versions the two commits declare decide, then, when
  * those match, their commit dates.
  */
-export function describeOlderCommit(dir: string, installed: string, candidate: string, label = candidate.slice(0, 7)): string | null {
-  if (installed === candidate || gitSucceeds(["merge-base", "--is-ancestor", installed, candidate], dir)) return null;
-  const installedVersion = versionAt(dir, installed);
-  const byVersion = compareSemver(versionAt(dir, candidate), installedVersion);
+export async function describeOlderCommit(dir: string, installed: string, candidate: string, label = candidate.slice(0, 7)): Promise<string | null> {
+  if (installed === candidate || await gitSucceedsAsync(["merge-base", "--is-ancestor", installed, candidate], dir)) return null;
+  const installedVersion = await versionAt(dir, installed);
+  const byVersion = compareSemver(await versionAt(dir, candidate), installedVersion);
   const older = () => `the registry's ${label} is older than the installed ${byVersion ? installedVersion : installed.slice(0, 7)}`;
-  if (gitSucceeds(["merge-base", "--is-ancestor", candidate, installed], dir)) return older();
+  if (await gitSucceedsAsync(["merge-base", "--is-ancestor", candidate, installed], dir)) return older();
   if (byVersion !== null && byVersion !== 0) return byVersion < 0 ? older() : null;
-  const candidateTime = Number(gitOutput(["show", "-s", "--format=%ct", candidate], dir));
-  const installedTime = Number(gitOutput(["show", "-s", "--format=%ct", installed], dir));
+  const candidateTime = Number(await gitOutputAsync(["show", "-s", "--format=%ct", candidate], dir));
+  const installedTime = Number(await gitOutputAsync(["show", "-s", "--format=%ct", installed], dir));
   return candidateTime > 0 && installedTime > 0 && candidateTime < installedTime ? older() : null;
 }
 
@@ -403,19 +404,29 @@ export interface PluginUpdateResult extends PluginDirectoryInfo {
   kept?: string;
 }
 
+function githubRepoFromUrl(url: string): string | null {
+  const match = /github\.com[:/]([^/]+)\/([^/]+?)(?:\.git)?$/i.exec(url.trim());
+  return match ? `${match[1]}/${match[2]}` : null;
+}
+
 /** `owner/repo` from the checkout's origin remote, or null for anything that is not a GitHub clone. */
 export function readPluginRemote(pluginDir: string): string | null {
   try {
-    const url = execFileSync("git", ["config", "--get", "remote.origin.url"], { cwd: pluginDir, stdio: ["ignore", "pipe", "ignore"] })
-      .toString("utf-8").trim();
-    const match = /github\.com[:/]([^/]+)\/([^/]+?)(?:\.git)?$/i.exec(url);
-    return match ? `${match[1]}/${match[2]}` : null;
+    return githubRepoFromUrl(execFileSync("git", ["config", "--get", "remote.origin.url"], { cwd: pluginDir, stdio: ["ignore", "pipe", "ignore"] })
+      .toString("utf-8"));
   } catch {
     // Intentional ignore: Hand-copied plugins and local repositories may have no origin remote.
     return null;
   }
 }
 
+/** `readPluginRemote` without holding the thread, for the app's own update check. */
+export async function readPluginRemoteAsync(pluginDir: string): Promise<string | null> {
+  // No origin remote (a hand-copied plugin, a local repository) is a failed git, and no repo.
+  const url = await gitOutputAsync(["config", "--get", "remote.origin.url"], pluginDir);
+  return url ? githubRepoFromUrl(url) : null;
+}
+
 /** The sha from `git ls-remote origin HEAD`; null when the answer is not one. */
 export function parseRemoteHead(output: string): string | null {
   const sha = output.trim().split(/\s+/)[0] ?? "";
@@ -500,7 +511,7 @@ export async function updatePlugin(name: string, options: PluginInstallOptions =
     const commit = await fetchPin(targetDir, pin, quiet);
     // Updates only move forward: a checkout installed from the default
     // branch can be ahead of the tag the registry reviewed.
-    const kept = before ? describeOlderCommit(targetDir, before, commit, pin.ref ?? commit.slice(0, 7)) : null;
+    const kept = before ? await describeOlderCommit(targetDir, before, commit, pin.ref ?? commit.slice(0, 7)) : null;
     if (kept) {
       if (!quiet) console.log(cliStyles.muted(`Kept ${name}: ${kept}.`));
       return { ...describe(targetDir, name, null), before, changed: false, kept };
@@ -510,7 +521,7 @@ export async function updatePlugin(name: string, options: PluginInstallOptions =
     // Not in the registry, so there is nothing reviewed to land on: follow the
     // remote's default branch, whether the checkout is on a branch or detached
     // from an earlier pin.
-    if (isOnBranch(targetDir)) {
+    if (await isOnBranch(targetDir)) {
       await git(["pull", "--ff-only"], targetDir, quiet, `Failed to update ${name}`);
     } else {
       await git(["fetch", "--depth", "1", "origin", "HEAD"], targetDir, quiet, `Failed to fetch ${name}`);

package/src/renderers/dom/desktop/icons.tsx

@@ -180,7 +180,7 @@ const ICONS: Record<IconName, ReactNode> = {
   ),
 };
 
-export function WebIcon({ name, size = 12, color }: IconProps) {
+export function WebIcon({ name, size = 12, color, fullHeight }: IconProps) {
   return (
     <svg
       viewBox="0 0 12 12"
@@ -189,7 +189,8 @@ export function WebIcon({ name, size = 12, color }: IconProps) {
       fill="none"
       aria-hidden="true"
       data-gloom-icon={name}
-      style={{ flex: "none", display: "block", color }}
+      // The viewBox keeps its size and sits in the middle of the taller box (preserveAspectRatio's default).
+      style={{ flex: "none", display: "block", color, ...(fullHeight ? { height: "100%" } : {}) }}
     >
       {ICONS[name]}
     </svg>

package/src/renderers/electrobun/bun/desktop/detached-windows.ts

@@ -18,6 +18,8 @@ import type { DesktopBackend } from "./backend";
 
 const INITIAL_DOCK_SUPPRESSION_MS = 800;
 const WINDOW_CONTROL_DOCK_SUPPRESSION_MS = 5_000;
+/** How long after the main window has its data the popped-out windows of the last session open. */
+const LAUNCH_WINDOWS_DELAY_MS = 300;
 
 export class DesktopDetachedWindowManager {
   private readonly windows = new Map<string, BrowserWindow>();
@@ -27,9 +29,29 @@ export class DesktopDetachedWindowManager {
   private readonly pendingMoveFlush = new Set<string>();
   private readonly suppressDockUntil = new Map<string, number>();
   private readonly windowControlDockSuppressed = new Set<string>();
+  /**
+   * At launch, popped-out windows wait for the main window. Opening a window
+   * holds this process until the system has made it (on Windows, its
+   * browser too), and the main window's `init` used to wait behind each one.
+   */
+  private windowsAllowed = false;
+  private windowsTimer: ReturnType<typeof setTimeout> | null = null;
 
   constructor(private readonly backend: DesktopBackend) {}
 
+  /**
+   * The main window has its data: the popped-out windows open shortly
+   * after, once it has had a moment to draw and ask for what it shows.
+   */
+  openAfterMainWindow(): void {
+    if (this.windowsAllowed || this.windowsTimer) return;
+    this.windowsTimer = setTimeout(() => {
+      this.windowsTimer = null;
+      this.windowsAllowed = true;
+      this.reconcile();
+    }, LAUNCH_WINDOWS_DELAY_MS);
+  }
+
   focusDetachedPane(instanceId: string): boolean {
     return this.focusWindowForRpcKey(detachedRpcKey(instanceId));
   }
@@ -88,7 +110,7 @@ export class DesktopDetachedWindowManager {
     for (const [instanceId, entry] of desiredEntries) {
       const existingWindow = this.windows.get(instanceId);
       if (!existingWindow) {
-        this.createWindow(instanceId, entry);
+        if (this.windowsAllowed) this.createWindow(instanceId, entry);
         continue;
       }
 

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

@@ -25,6 +25,7 @@ import { telemetryOptedOut } from "../../../../telemetry/crash-reports";
 import { describeNodeOs, readOrCreateInstallId } from "../../../../telemetry/crash-reports-node";
 import type { DesktopBackend, DesktopRpc } from "./backend";
 import { readDesktopViewIds } from "./view-ids";
+import { markStartupComplete } from "../../../../utils/main-thread-stall";
 
 interface DesktopWindowTarget {
   kind: "main" | "detached";
@@ -194,5 +195,12 @@ export async function initializeDesktopBackend(
     backend.workspace = createDesktopWorkspace(config, backend.getSessionSnapshot());
     backend.detachedWindows.reconcile();
   }
-  return buildInitializationPayload(backend, config, services, windowTarget);
+  const init = buildInitializationPayload(backend, config, services, windowTarget);
+  // The main window has what it needs to draw: this process is up, and the
+  // popped-out windows open next.
+  if (windowTarget.kind === "main") {
+    markStartupComplete();
+    backend.detachedWindows.openAfterMainWindow();
+  }
+  return init;
 }

package/src/renderers/electrobun/bun/window/attention.ts

@@ -0,0 +1,54 @@
+import { setStallAttentionProbe, type StallAttention } from "../../../../telemetry/stall-reports";
+
+/** What this needs of a window: its id, its minimized state and its events. */
+interface AttentionWindow {
+  id: number;
+  isMinimized(): boolean;
+  on?(name: string, handler: (event: unknown) => void): void;
+}
+
+const openWindows = new Map<number, AttentionWindow>();
+let focusedWindowId: number | null = null;
+let sawFocusChange = false;
+
+/**
+ * Whether anyone was looking when the desktop app's Bun process froze. The
+ * system slows a hidden app's timers, which reads like a freeze, so a stall
+ * report from this process says whether one of the app's windows had the
+ * keyboard (the app was in front) and whether one was open and not
+ * minimized. Read only for a stall about to be reported.
+ */
+function desktopAttention(): StallAttention {
+  let visible: boolean | null = false;
+  try {
+    for (const window of openWindows.values()) {
+      if (!window.isMinimized()) {
+        visible = true;
+        break;
+      }
+    }
+  } catch {
+    visible = null;
+  }
+  return { active: sawFocusChange ? focusedWindowId !== null : null, visible };
+}
+
+/** Follows a window the app opened until it closes; the first one installs the probe. */
+export function trackWindowAttention(window: AttentionWindow): void {
+  if (openWindows.size === 0) setStallAttentionProbe(desktopAttention);
+  openWindows.set(window.id, window);
+  window.on?.("focus", () => {
+    focusedWindowId = window.id;
+    sawFocusChange = true;
+  });
+  window.on?.("blur", () => {
+    // Focus moving between two of the app's windows can report the new
+    // window's focus before the old one's blur.
+    if (focusedWindowId === window.id) focusedWindowId = null;
+    sawFocusChange = true;
+  });
+  window.on?.("close", () => {
+    openWindows.delete(window.id);
+    if (focusedWindowId === window.id) focusedWindowId = null;
+  });
+}

package/src/renderers/electrobun/bun/window/create.ts

@@ -1,4 +1,5 @@
 import { BrowserWindow } from "electrobun/bun";
+import { trackWindowAttention } from "./attention";
 import {
   applyNativeWindowFrame,
   applyWindowMoveEvent,
@@ -105,6 +106,7 @@ export function createAppWindow({ title, frame, rpc, minSize, onFrameChange, pre
     });
   }
   updateWindowFrameCache(window, frame, minSize);
+  trackWindowAttention(window);
   const readsNativeFrame = process.platform === "win32";
   (window as any).on?.("move", (event: WindowMoveEvent) => {
     if (readsNativeFrame) {

package/src/renderers/electrobun/launcher/preload.ts

@@ -0,0 +1,13 @@
+// Runs first in Electrobun's launcher script (Resources/main.js) on Windows,
+// before it starts the app's worker and the browser engine. The Windows build
+// step puts it there (scripts/install-electrobun-tui-shim.ts).
+import { leaveEmulationFaultsToWindows } from "./windows-emulation";
+
+if (process.platform === "win32") {
+  try {
+    const result = leaveEmulationFaultsToWindows();
+    if (result !== "not emulated") console.log(`[launcher] x64 emulation: ${result}`);
+  } catch (error) {
+    console.error("[launcher] could not check for x64 emulation", error);
+  }
+}

package/src/renderers/electrobun/launcher/windows-emulation.ts

@@ -0,0 +1,50 @@
+import { dlopen, ptr, read, type Pointer } from "bun:ffi";
+
+// Windows on Arm runs the x64 app under emulation. When a thread exits there,
+// Windows' emulation layer can fault on memory it no longer reaches
+// (ntdll!RtlEcContextToNativeContext) and recovers from that fault itself.
+// Bun 1.3's crash handler is a vectored exception handler, so it sees the
+// fault before Windows does and takes it for a crash. On the exiting thread,
+// which has no thread-local storage left, the handler then faults inside
+// itself until the thread's stack is gone, and the app closes some seconds
+// after it opens. Bun 1.4 only claims faults inside its own code. Until the
+// app runs on it, remove Bun's handler under emulation and leave faults to
+// Windows, which still reports a real crash.
+
+// The Bun build Electrobun ships, by link timestamp, and where that build
+// keeps the handle of its vectored exception handler (from its symbols).
+const BUN_HANDLER_HANDLES = new Map<number, number>([
+  [0x69e4847f, 0x68e3d40], // Bun 1.3.13, bun-windows-x64-baseline
+]);
+
+const IMAGE_FILE_MACHINE_ARM64 = 0xaa64;
+const CURRENT_PROCESS = -1;
+
+export type EmulationFaultsResult = "not emulated" | "other bun build" | "handler already gone" | "handler removed" | "handler not found";
+
+export function leaveEmulationFaultsToWindows(): EmulationFaultsResult {
+  const kernel32 = dlopen("kernel32.dll", {
+    GetModuleHandleW: { args: ["ptr"], returns: "ptr" },
+    IsWow64Process2: { args: ["i64", "ptr", "ptr"], returns: "i32" },
+    RemoveVectoredExceptionHandler: { args: ["ptr"], returns: "u32" },
+  });
+  try {
+    const processMachine = new Uint16Array(1);
+    const nativeMachine = new Uint16Array(1);
+    if (!kernel32.symbols.IsWow64Process2(CURRENT_PROCESS, ptr(processMachine), ptr(nativeMachine))) return "not emulated";
+    if (nativeMachine[0] !== IMAGE_FILE_MACHINE_ARM64) return "not emulated";
+
+    const image = kernel32.symbols.GetModuleHandleW(null);
+    if (!image) return "other bun build";
+    const timestamp = read.u32(image, read.u32(image, 0x3c) + 8);
+    const handleOffset = BUN_HANDLER_HANDLES.get(timestamp);
+    if (handleOffset === undefined) return "other bun build";
+
+    const handle = read.ptr(image, handleOffset) as Pointer;
+    if (!handle) return "handler already gone";
+    // Windows only removes a handle it has registered, so a wrong value does nothing.
+    return kernel32.symbols.RemoveVectoredExceptionHandler(handle) ? "handler removed" : "handler not found";
+  } finally {
+    kernel32.close();
+  }
+}

package/src/renderers/electrobun/view/ui-host.tsx

@@ -25,9 +25,16 @@ export const webRendererHost: RendererHost = {
       void backendRequest("host.exit").catch(() => window.close());
     });
   },
-  startWindowDrag() {
-    // Windows moves the window itself, as it does from a native title bar.
+  startWindowDrag(press) {
+    // Windows moves the window itself, as it does from a native title bar, and
+    // a double-click there maximizes or restores it.
     if (detectPlatform() === "win32") {
+      if (press?.detail === 2) {
+        void backendRequest("host.windowControl", { action: "toggle-maximize" }).catch((error: unknown) => {
+          console.error("[desktop] could not maximize the window", error instanceof Error ? error.message : String(error));
+        });
+        return;
+      }
       void backendRequest("host.startWindowDrag").catch((error: unknown) => {
         console.error("[desktop] could not start moving the window", error instanceof Error ? error.message : String(error));
       });

package/src/series/resolve.ts

@@ -195,7 +195,7 @@ export async function resolveLoadedSeries(
 ): Promise<ResolvedSeries> {
   const ticker = request.ticker?.trim().toUpperCase() || undefined;
   const line = definition.lines?.length ? request.line ?? definition.lines[0] : undefined;
-  const { points, edge, warning, attribution } = loadResult(await loadSeries(definition, {
+  const { points, edge, warning, savedAt, attribution } = loadResult(await loadSeries(definition, {
     ...seriesLoadWindow(request.viewport, now),
     ...(ticker ? { ticker } : {}),
     ...viewportBars(request.viewport, ticker),
@@ -221,6 +221,7 @@ export async function resolveLoadedSeries(
     panelId: "main",
     interpolation: style === "step" ? "step-after" : "none",
     ...(warning ? { warning } : {}),
+    ...(savedAt != null && Number.isFinite(savedAt) ? { savedAt } : {}),
     ...(attribution ? { attribution: { ...attribution } } : {}),
     points: normalizeSeriesPoints(points, edge),
   };

package/src/series/types.ts

@@ -92,6 +92,11 @@ export interface SeriesLoadResult {
   points: readonly SeriesPoint[];
   /** A note the chart shows above the plot, such as "cached data is stale". */
   warning?: string;
+  /**
+   * When the copy the points came from was saved (ms), when its refresh failed
+   * and that copy answered: the chart's footer says "saved copy from …".
+   */
+  savedAt?: number;
   /** What a report of this series cites in place of Gloom Cloud. */
   attribution?: SeriesAttribution;
 }

package/src/sources/gloomberb-cloud/fred-series.ts

@@ -1,4 +1,4 @@
-import { createPluginCache } from "../../data/plugin-cache";
+import { createPluginCache, savedCopyForTransientFailure } from "../../data/plugin-cache";
 import { getPublishedUsEquityCalendarDay } from "../../market-data/published-us-sessions";
 import { zonedDateKey } from "../../utils/zoned-date-time";
 import type {
@@ -198,7 +198,9 @@ export async function loadCachedFredSeries(
   const cached = stored ? withFredSourceFreshness(stored) : null;
   if (!options?.force && !pending && cached && !cached.stale) return { ...cached, source: "cache" };
   const result = await cache.load(cacheKey(request), loader, pending ? { ...options, force: true } : options);
-  // An early re-read is opportunistic: a failure keeps the still-fresh copy as it was.
+  // An early re-read is opportunistic: a failure keeps the still-fresh copy as it was, as not asking would have.
   if (pending && result.source === "stale-fallback" && cached && !cached.stale && !options?.force) return { ...cached, source: "cache" };
-  return withFredSourceFreshness(result);
+  // A refusal (a series no longer served, a signed-out session) or a reply that fails validation is thrown,
+  // whatever copy is saved: a saved copy answers only for a failure asking again may get past.
+  return withFredSourceFreshness(savedCopyForTransientFailure(result));
 }

package/src/telemetry/stall-reports-node.ts

@@ -31,7 +31,18 @@ function parseStallReportState(text: string): StallReportState {
       if (typeof at === "number" && Number.isFinite(at)) sent[key] = at;
     }
   }
-  return { sent, pending: readCounts(record.pending) };
+  return { sent, pending: readCounts(record.pending), recent: readTimes(record.recent) };
+}
+
+function readTimes(value: unknown): NonNullable<StallReportState["recent"]> {
+  const recent: NonNullable<StallReportState["recent"]> = {};
+  if (!value || typeof value !== "object") return recent;
+  for (const [process, times] of Object.entries(value as Record<string, unknown>)) {
+    if (!Array.isArray(times)) continue;
+    const kept = times.filter((at): at is number => typeof at === "number" && Number.isFinite(at));
+    if (kept.length > 0) recent[process] = kept;
+  }
+  return recent;
 }
 
 function trimLog(path: string): void {
@@ -62,7 +73,7 @@ export function createNodeStallReporterHost(options: {
     },
     load: () => {
       const path = pathFor(STATE_FILE);
-      if (!path || !existsSync(path)) return { sent: {}, pending: {} };
+      if (!path || !existsSync(path)) return { sent: {}, pending: {}, recent: {} };
       return parseStallReportState(readFileSync(path, "utf-8"));
     },
     save: (state) => {