gloomberb 0.19.0 → 0.19.2

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/shared/protocol.ts

@@ -212,6 +212,8 @@ interface DesktopBackendRequestMap {
   "host.exit": { request: null; response: null };
   "host.windowControl": { request: { action: DesktopWindowControlAction }; response: null };
   "host.windowFullscreen": { request: null; response: boolean };
+  /** Windows: moves the window with the pointer through the system's own move loop. */
+  "host.startWindowDrag": { request: null; response: null };
   "host.openExternal": { request: { url: string }; response: boolean };
   "host.copyText": { request: { text: string }; response: null };
   "host.focusWindow": { request: null; response: null };

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

@@ -2,6 +2,7 @@ import { apiClient } from "../../../api-client";
 import { newsProvider, type NewsCapability } from "../../../capabilities";
 import { cloudNewsReadArticles, mapCloudNewsArticle, readCloudNews } from "../../../sources/gloomberb-cloud/news";
 import type { NewsArticle, NewsPage, NewsQuery } from "../../../news/types";
+import { readCompanyFrom } from "../../../types/company-from";
 
 interface BackendNews {
   id: string;
@@ -34,6 +35,7 @@ export function createDesktopNewsSource(backend: BackendNews, client: CloudNewsC
             articles: cloudNewsReadArticles(read, query.ticker),
             nextCursor: read.nextCursor ?? null,
             access: read.access ?? null,
+            companyFrom: readCompanyFrom(read.companyFrom),
           };
         } catch {
           // The aggregate page keeps RSS failures beside any usable stories.

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

@@ -5,6 +5,7 @@ import { backendRequest } from "./backend-rpc";
 import { NATIVE_CONTEXT_MENU_SUPPORTED, showDesktopContextMenu } from "./host/native";
 import { startElectrobunWindowDrag } from "./host/window-move";
 import { createDomUiHost } from "../../dom/dom-ui-host";
+import { detectPlatform } from "../../../utils/platform";
 
 export function createWebUiHost(desktopPlatform?: string): UiHost {
   return createDomUiHost(desktopPlatform, {
@@ -24,7 +25,21 @@ export const webRendererHost: RendererHost = {
       void backendRequest("host.exit").catch(() => window.close());
     });
   },
-  startWindowDrag() {
+  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));
+      });
+      return;
+    }
     startElectrobunWindowDrag();
   },
   async controlWindow(action) {

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 {
@@ -42,6 +42,8 @@ export interface FredSeriesCacheEntry {
 export interface FredSeriesLoadResult extends FredSeriesCacheEntry {
   source: "cache" | "network" | "stale-fallback";
   refreshError?: string;
+  /** What the failed refresh threw, when a saved copy answered (`stale-fallback`). */
+  error?: unknown;
 }
 
 const cache = createPluginCache<FredSeriesData>({
@@ -196,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.
-  if (pending && result.refreshError && cached && !cached.stale && !options?.force) return { ...cached, source: "cache" };
-  return withFredSourceFreshness(result);
+  // 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" };
+  // 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/sources/gloomberb-cloud/index.ts

@@ -1,4 +1,5 @@
 import { logFailure } from "../../utils/log-failure";
+import { readCompanyFrom } from "../../types/company-from";
 import { exchangeRateMetadata } from "../../utils/exchange-rate-snapshot";
 import type { ExchangeRateSnapshot } from "../../types/exchange-rate";
 import type { TimeRange } from "../../time-series/range";
@@ -42,7 +43,7 @@ import {
 import type { NewsArticle, NewsQuery } from "../../types/news-source";
 import { normalizeNewsFeed } from "../../news/news-model";
 import { resolveCurrencyUnit } from "../../utils/currency-units";
-import { isRoundTheClockCoin } from "../../utils/crypto-pair";
+import { exchangeLineCoinListing, isRoundTheClockCoin, withExchangeLinesAsCoinListings } from "../../utils/crypto-pair";
 import { canonicalExchange, canonicalTickerKey, parsePublicTickerKey } from "../../utils/exchanges";
 import { normalizePriceHistory, priceHistoryIntervalMs, reachesLatestSettledSession } from "../../utils/price-history";
 import { createProviderMiss, ProviderBusyError, providerMissReason, StaleHistoryError } from "../provider-errors";
@@ -315,14 +316,35 @@ function cloudResponseTargetKey(key: string, requested: Set<string>): string | u
 
 /**
  * The listing as Gloom Cloud knows it. A Hong Kong code goes out with its four
- * digits: Cloud has no 700 or 5 on HKEX, only 0700 and 0005.
+ * digits: Cloud has no 700 or 5 on HKEX, only 0700 and 0005. A crypto
+ * exchange's line of a coin pair (BTC/GBP on COINBASE PRO), which no source
+ * quotes, goes out as the crypto venue's listing of the pair, BTC-GBP on CCC.
  */
 function cloudInstrumentTarget(symbol: string, exchange?: string) {
   rejectPredictionMarket(symbol, exchange);
   const target = publicListingTarget(symbol, exchange);
+  const coin = exchangeLineCoinListing(target.symbol, target.exchange);
+  if (coin) return { symbol: coin.symbol, exchange: coin.exchange };
   return target.exchange ? { ...target, symbol: hongKongListingCode(target.symbol, target.exchange) } : target;
 }
 
+/**
+ * Whether a quote names a listing other than the one asked for: asked for BHP
+ * on Cboe Australia, Gloom Cloud has answered with BHP on NYSE, in dollars. A
+ * price for another instrument is worse than none. A quote that names no
+ * listing is judged by its symbol alone, as the router judges it.
+ */
+function pricesOtherListing(quote: Quote, target: ReturnType<typeof cloudInstrumentTarget>): boolean {
+  const metadata = quoteMetadataFromQuote(quote);
+  const named = !!(metadata.listingExchangeName || parsePublicTickerKey(quote.symbol).exchange);
+  return !quoteMetadataMatchesTarget(metadata, named ? target.symbol : parsePublicTickerKey(target.symbol).symbol, named ? target.exchange : undefined);
+}
+
+function otherListingMiss(ticker: string, quote: Quote) {
+  const venue = quote.listingExchangeName || quote.exchangeName || parsePublicTickerKey(quote.symbol).exchange;
+  return createProviderMiss(`Cloud quoted ${quote.symbol}${venue ? ` on ${venue}` : ""} for ${ticker}`);
+}
+
 function cloudHistoryRecovery(
   context: MarketDataRequestContext | undefined,
   ticker: string, symbol: string, exchange: string, interval: string, start: Date, end: Date,
@@ -520,10 +542,12 @@ export class GloomberbCloudProvider implements AssetDataProvider {
     return withCloudFallback(
       async () => {
         const response = await apiClient.getCloudQuote(target.symbol, target.exchange);
-        const quote = retainRequestedQuoteSymbol(mapQuote(
+        const answered = mapQuote(
           unwrapRequiredCloudResponse(response, `Cloud quotes are unavailable for ${ticker}`),
           response.providerMeta,
-        ), ticker);
+        );
+        if (pricesOtherListing(answered, target)) throw otherListingMiss(ticker, answered);
+        const quote = retainRequestedQuoteSymbol(answered, ticker);
         // A stale answer is the last price the service has. It stays flagged, so
         // no freshness check passes it and only a request with no current quote
         // from any source falls back to it.
@@ -585,7 +609,11 @@ export class GloomberbCloudProvider implements AssetDataProvider {
           return { target, quote: null, error: createProviderMiss(`Cloud quotes are stale for ${target.symbol}`) };
         }
         if ((item.status === "success" || item.status === "partial") && item.data) {
-          const quote = retainRequestedQuoteSymbol(mapQuote(item.data), target.symbol);
+          const answered = mapQuote(item.data);
+          if (pricesOtherListing(answered, cloudInstrumentTarget(target.symbol, target.exchange))) {
+            return { target, quote: null, error: otherListingMiss(target.symbol, answered) };
+          }
+          const quote = retainRequestedQuoteSymbol(answered, target.symbol);
           return { target, quote: item.stale === true ? { ...quote, stale: true } : quote };
         }
         return {
@@ -617,8 +645,9 @@ export class GloomberbCloudProvider implements AssetDataProvider {
     // Perpetual markets are listings too, asked for beside the others. They are optional: a failed lookup leaves the
     // other results, and a keystroke waits for them only briefly once the listings are in, unless the query names one.
     const pending = searchPerpetualMarkets(query).catch(logFailure("sources.gloomberb-cloud.index", "Searching perpetual markets failed", [] as InstrumentSearchResult[]));
+    // A crypto exchange's line of a coin pair, which no source quotes, is offered as the crypto venue's listing.
     const listings = await withCloudFallback(
-      () => apiClient.searchInstruments(query, context?.limit ?? 10),
+      async () => withExchangeLinesAsCoinListings(await apiClient.searchInstruments(query, context?.limit ?? 10)),
       "Cloud search is unavailable",
     ).catch((error: unknown) => {
       // Rate limited or overloaded: the search was not run, which is not a search that found nothing.
@@ -637,9 +666,12 @@ export class GloomberbCloudProvider implements AssetDataProvider {
     const name = venue ? context?.listingName?.trim() || await this.listingName(ticker, venue) || undefined : undefined;
     const filings = await withCloudFallback(async () => {
       const response = await apiClient.getCloudSecFilings({ ticker, exchange, name, limit: count, offset: 0 });
-      return response.filings.map(mapCloudSecFiling);
+      // A foreign line's filings read from its company's home line say whose, each of them.
+      const companyFrom = readCompanyFrom(response.companyFrom);
+      return response.filings.map((filing) => companyFrom ? { ...mapCloudSecFiling(filing), companyFrom } : mapCloudSecFiling(filing));
     }, `Cloud SEC filings are unavailable for ${ticker}`);
-    if (!venue || filings.length === 0) return filings;
+    // The service matched a line read from its company's home line to the company itself.
+    if (!venue || filings.length === 0 || filings[0]!.companyFrom) return filings;
     const symbol = parsePublicTickerKey(ticker).symbol;
     // Without the listing's company the filings cannot be told apart from another company's.
     if (!name) throw createProviderMiss(`SEC filings for ${symbol} could not be matched to its ${venue} listing`);
@@ -732,6 +764,7 @@ export class GloomberbCloudProvider implements AssetDataProvider {
   async searchBatch(queries: string[], options: { limit?: number; signal?: AbortSignal } = {}): Promise<Map<string, InstrumentSearchResult[]> | null> {
     const answers = await cloudSearchBatch(queries, options);
     if (!answers) return null;
+    for (const [query, rows] of answers) answers.set(query, withExchangeLinesAsCoinListings(rows));
     // Perpetual markets lead each answer, as `search` gives them, so a symbol in a list resolves as it does alone:
     // one read of the board answers every query's search of it. A query that found no listing is searched again
     // on its own, which finds them then; a board that does not answer leaves them out, as a search does.
@@ -965,6 +998,7 @@ export function createGloomberbCloudCapabilities(provider = createGloomberbCloud
             articles: cloudNewsReadArticles(read, query.ticker),
             nextCursor: read.nextCursor ?? null,
             access: read.access ?? null,
+            companyFrom: readCompanyFrom(read.companyFrom),
           };
         },
         async fetchNews(query: NewsQuery): Promise<NewsArticle[]> {

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) => {

package/src/telemetry/stall-reports.ts

@@ -22,8 +22,18 @@ import { reportCrash } from "./crash-reports";
  *   stall and how many there were. No free text: a section name keeps only
  *   its fixed leading part, so a ticker in a queue key never leaves.
  *
+ * A report also says when in the process's life the stall came (still
+ * starting or up, and an uptime bucket), how long before it the named section
+ * ended (or that it ended inside it, which makes it the likely cause), and,
+ * for the desktop app's own process, whether the app was in front and had a
+ * window on screen: a hidden app's slowed timers read like a freeze. A stall
+ * after a SQLite statement names the statement (a fixed name), its tries and
+ * whether it waited on another program's lock. All of it is buckets and
+ * flags.
+ *
  * One report per process, bucket, section and app version a day; stalls of
- * the same kind after that are counted and carried in the next report.
+ * the same kind after that are counted and carried in the next report, and
+ * every report says how many stalls the process had in the last day.
  */
 
 /** Which process stalled. */
@@ -41,9 +51,34 @@ export interface StallReport {
   count: number;
   /** The longest of them, rounded to 100 ms. */
   longestMs: number;
+  /** This process's stalls of a second or more in the last 24 hours, this one included. */
+  day: number;
+  /** Whether the process had finished starting. */
+  phase: "startup" | "steady" | "unknown";
+  uptime: UptimeBucket | "unknown";
+  /** How long before the stall began the section ended; "in" when it ended inside it. */
+  gap: GapBucket;
+  /** The desktop app's own process: whether the app was in front (null: not known yet). */
+  active?: boolean | null;
+  /** The desktop app's own process: whether a window was open and not minimized. */
+  visible?: boolean | null;
+  /** After a SQLite statement: how many tries it took. */
+  attempts?: number;
+  /** After a SQLite statement: whether it waited on another connection's lock. */
+  lockWait?: boolean;
 }
 
 type StallBucket = "1-2s" | "2-5s" | "5-15s" | "15s+";
+type UptimeBucket = "<30s" | "30s-2m" | "2-10m" | "10-60m" | "1-6h" | "6-24h" | "1d+";
+type GapBucket = "none" | "in" | "<1s" | "1-10s" | "10-60s" | "1-10m" | "10m+";
+
+/** What the desktop app's Bun process can tell about whether anyone was looking. */
+export interface StallAttention {
+  /** One of the app's windows had the keyboard; null before the first focus change. */
+  active: boolean | null;
+  /** One of the app's windows was open and not minimized; null when it could not be read. */
+  visible: boolean | null;
+}
 
 /** What the host keeps on disk between launches. */
 export interface StallReportState {
@@ -51,6 +86,8 @@ export interface StallReportState {
   sent: Record<string, number>;
   /** Stalls counted since each kind was last reported. */
   pending: Record<string, { count: number; longestMs: number }>;
+  /** When each process's stalls of a second or more in the last day happened, oldest first. */
+  recent?: Record<string, number[]>;
 }
 
 export interface StallReporterHost {
@@ -74,8 +111,13 @@ const SECTION_PATTERN = /^[a-z][a-z0-9-]*(?:\.[a-z][a-z0-9-]*)*/;
 const VERSION_PATTERN = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]{1,60})?$/;
 /** Kinds with counts waiting for their next report; the oldest go first past this. */
 const MAX_KINDS_KEPT = 200;
+/** Stall times kept per process for the day count. */
+const MAX_RECENT_KEPT = 500;
+/** What error tracking keeps of the details line; fields that do not fit are left out. */
+const MAX_DETAILS_LENGTH = 120;
 
 let host: StallReporterHost | null = null;
+let attentionProbe: (() => StallAttention) | null = null;
 
 /** The fixed part of a section name: lower-case dotted words, cut where anything else starts. */
 function stallSectionName(name: string | undefined): string {
@@ -85,6 +127,15 @@ function stallSectionName(name: string | undefined): string {
   return section && section.length <= 80 ? section : "unmeasured";
 }
 
+/** The section a report names; a SQLite statement's adds the statement's fixed name. */
+function reportSection(event: StallEvent): string {
+  const section = stallSectionName(event.lastMeasured);
+  if (section !== "sqlite.blocked" || !event.sqlite) return section;
+  const operation = event.sqlite.operation.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40);
+  const named = `${section}.${operation}`.replace(/-+$/, "");
+  return SECTION_PATTERN.exec(named)?.[0] === named ? named : section;
+}
+
 function stallBucket(blockedMs: number): StallBucket {
   if (blockedMs < 2_000) return "1-2s";
   if (blockedMs < 5_000) return "2-5s";
@@ -92,15 +143,50 @@ function stallBucket(blockedMs: number): StallBucket {
   return "15s+";
 }
 
+function uptimeBucket(uptimeMs: number | undefined): UptimeBucket | "unknown" {
+  if (uptimeMs === undefined) return "unknown";
+  const minutes = uptimeMs / 60_000;
+  if (minutes < 0.5) return "<30s";
+  if (minutes < 2) return "30s-2m";
+  if (minutes < 10) return "2-10m";
+  if (minutes < 60) return "10-60m";
+  if (minutes < 360) return "1-6h";
+  if (minutes < 1_440) return "6-24h";
+  return "1d+";
+}
+
+/**
+ * How long before the stall began the last measured section ended. A
+ * section that ended inside the stall ran during it ("in"): the likely
+ * cause. Anything after that is time nothing measured ran in.
+ */
+function gapBucket(event: StallEvent): GapBucket {
+  if (!event.lastMeasured || event.lastMeasuredEndedMsAgo === undefined) return "none";
+  const gapMs = event.lastMeasuredEndedMsAgo - event.blockedMs;
+  if (gapMs <= 0) return "in";
+  if (gapMs < 1_000) return "<1s";
+  if (gapMs < 10_000) return "1-10s";
+  if (gapMs < 60_000) return "10-60s";
+  if (gapMs < 600_000) return "1-10m";
+  return "10m+";
+}
+
 /** A stall another process sent over, kept only when it has the right shape. */
 export function parseStallEvent(value: unknown): StallEvent | null {
   if (!value || typeof value !== "object") return null;
-  const { blockedMs, lastMeasured, lastMeasuredEndedMsAgo } = value as Record<string, unknown>;
+  const { blockedMs, lastMeasured, lastMeasuredEndedMsAgo, sqlite, uptimeMs, phase } = value as Record<string, unknown>;
   if (typeof blockedMs !== "number" || !Number.isFinite(blockedMs) || blockedMs <= 0) return null;
+  const detail = sqlite && typeof sqlite === "object" ? sqlite as Record<string, unknown> : null;
   return {
     blockedMs,
     ...(typeof lastMeasured === "string" && lastMeasured.length <= 200 ? { lastMeasured } : {}),
     ...(typeof lastMeasuredEndedMsAgo === "number" && Number.isFinite(lastMeasuredEndedMsAgo) ? { lastMeasuredEndedMsAgo } : {}),
+    ...(detail && typeof detail.operation === "string" && detail.operation.length <= 80
+      && typeof detail.attempts === "number" && Number.isFinite(detail.attempts)
+      ? { sqlite: { operation: detail.operation, attempts: detail.attempts, lockWait: detail.lockWait === true } }
+      : {}),
+    ...(typeof uptimeMs === "number" && Number.isFinite(uptimeMs) && uptimeMs >= 0 ? { uptimeMs } : {}),
+    ...(phase === "startup" || phase === "steady" ? { phase } : {}),
   };
 }
 
@@ -108,13 +194,43 @@ function formatSeconds(ms: number): string {
   return `${(ms / 1000).toFixed(ms < 10_000 ? 1 : 0)} s`;
 }
 
-/** One line of the stall log: when, which process, how long, and what ran last. */
-function formatStallLogLine(process: StallProcess, event: StallEvent, at: number): string {
+function flag(value: boolean | null | undefined): string {
+  return value == null ? "?" : value ? "1" : "0";
+}
+
+/** The context a report carries, also written at the end of the log line. */
+interface StallContext {
+  phase: StallReport["phase"];
+  uptime: StallReport["uptime"];
+  gap: GapBucket;
+  attention: StallAttention | null;
+}
+
+function stallContext(event: StallEvent, attention: StallAttention | null): StallContext {
+  return {
+    phase: event.phase ?? "unknown",
+    uptime: uptimeBucket(event.uptimeMs),
+    gap: gapBucket(event),
+    attention,
+  };
+}
+
+/** One line of the stall log: when, which process, how long, what ran last, and when in the process's life. */
+function formatStallLogLine(process: StallProcess, event: StallEvent, context: StallContext, at: number): string {
   const time = new Date(at).toISOString().replace(/\.\d{3}Z$/, "Z");
   const last = event.lastMeasured
     ? `last measured: ${event.lastMeasured}${event.lastMeasuredEndedMsAgo === undefined ? "" : `, ended ${Math.round(event.lastMeasuredEndedMsAgo)} ms before`}`
     : "nothing measured before it";
-  return `${time}  ${process.padEnd(8)}  froze ${formatSeconds(event.blockedMs).padStart(6)}  ${last}`;
+  const sqlite = event.sqlite
+    ? ` (${event.sqlite.operation}, ${event.sqlite.attempts} ${event.sqlite.attempts === 1 ? "try" : "tries"}${event.sqlite.lockWait ? ", waited on a lock" : ""})`
+    : "";
+  const facts = [
+    `phase=${context.phase}`,
+    `up=${context.uptime}`,
+    `gap=${context.gap}`,
+    ...(context.attention ? [`fg=${flag(context.attention.active)}`, `vis=${flag(context.attention.visible)}`] : []),
+  ].join(" ");
+  return `${time}  ${process.padEnd(8)}  froze ${formatSeconds(event.blockedMs).padStart(6)}  ${last}${sqlite}  [${facts}]`;
 }
 
 function reportPlatform(platform: string): StallReport["platform"] {
@@ -128,13 +244,35 @@ function reportArch(arch: string): StallReport["arch"] {
   return arch === "arm64" || arch === "x64" ? arch : "other";
 }
 
-function sendThroughCrashReporter(report: StallReport): void {
-  const details = [
+/**
+ * The details line error tracking keeps, most telling first: the original
+ * four fields, then the new ones. One that would not fit is left out.
+ */
+export function formatStallReportDetails(report: StallReport): string {
+  const fields = [
     `process=${report.process}`,
     `count=${report.count}`,
     `longest=${report.longestMs}ms`,
     `platform=${report.platform}-${report.arch}`,
-  ].join(" ");
+    `phase=${report.phase}`,
+    `up=${report.uptime}`,
+    `gap=${report.gap}`,
+    ...(report.active === undefined ? [] : [`fg=${flag(report.active)}`]),
+    ...(report.visible === undefined ? [] : [`vis=${flag(report.visible)}`]),
+    ...(report.lockWait === undefined ? [] : [`lock=${flag(report.lockWait)}`]),
+    ...(report.attempts === undefined ? [] : [`try=${report.attempts}`]),
+    `day=${report.day}`,
+  ];
+  let details = "";
+  for (const field of fields) {
+    const next = details ? `${details} ${field}` : field;
+    if (next.length <= MAX_DETAILS_LENGTH) details = next;
+  }
+  return details;
+}
+
+function sendThroughCrashReporter(report: StallReport): void {
+  const details = formatStallReportDetails(report);
   // A plain object, not an Error: it has no stack, so no file path goes along.
   // The message is the bucket and section, so error tracking keeps one issue per kind.
   reportCrash(
@@ -146,10 +284,10 @@ function sendThroughCrashReporter(report: StallReport): void {
 function loadState(current: StallReporterHost): StallReportState {
   try {
     const state = current.load();
-    return { sent: { ...state.sent }, pending: { ...state.pending } };
+    return { sent: { ...state.sent }, pending: { ...state.pending }, recent: { ...state.recent } };
   } catch (error) {
     logFailure("telemetry-stalls", "Could not read stall report state")(error);
-    return { sent: {}, pending: {} };
+    return { sent: {}, pending: {}, recent: {} };
   }
 }
 
@@ -159,6 +297,22 @@ function prune(state: StallReportState, now: number): void {
   }
   const kinds = Object.keys(state.pending);
   for (const key of kinds.slice(0, Math.max(0, kinds.length - MAX_KINDS_KEPT))) delete state.pending[key];
+  for (const [process, times] of Object.entries(state.recent ?? {})) {
+    const kept = times.filter((at) => now - at < DAY_MS && at <= now);
+    if (kept.length > 0) state.recent![process] = kept;
+    else delete state.recent![process];
+  }
+}
+
+/** Never throws: a probe that fails reads as not known. */
+function readAttention(): StallAttention | null {
+  if (!attentionProbe) return null;
+  try {
+    return attentionProbe();
+  } catch {
+    // Intentional ignore: a window that cannot be read leaves the report saying it is not known.
+    return { active: null, visible: null };
+  }
 }
 
 /** Records one stall of `process`. Does nothing where no host is installed; never throws. */
@@ -167,15 +321,20 @@ export function recordStall(process: StallProcess, event: StallEvent): void {
   if (!current || !(event.blockedMs > 0)) return;
   try {
     const now = current.now?.() ?? Date.now();
-    current.appendLog(formatStallLogLine(process, event, now));
-    if (event.blockedMs < STALL_REPORT_MIN_MS) return;
+    const reportable = event.blockedMs >= STALL_REPORT_MIN_MS;
+    // Asked only of a stall that will be reported: the probe reads the windows.
+    const context = stallContext(event, reportable && process === "app" ? readAttention() : null);
+    current.appendLog(formatStallLogLine(process, event, context, now));
+    if (!reportable) return;
     const appVersion = (current.appVersion ?? VERSION).trim().replace(/^v/, "");
-    const section = stallSectionName(event.lastMeasured);
+    const section = reportSection(event);
     const bucket = stallBucket(event.blockedMs);
     const version = VERSION_PATTERN.test(appVersion) ? appVersion : "unknown";
     const key = `${process}|${bucket}|${section}|${version}`;
     const state = loadState(current);
     prune(state, now);
+    const recent = [...(state.recent?.[process] ?? []), now].slice(-MAX_RECENT_KEPT);
+    state.recent = { ...state.recent, [process]: recent };
     const pending = state.pending[key] ?? { count: 0, longestMs: 0 };
     pending.count += 1;
     pending.longestMs = Math.max(pending.longestMs, Math.round(event.blockedMs / 100) * 100);
@@ -193,6 +352,14 @@ export function recordStall(process: StallProcess, event: StallEvent): void {
         arch: reportArch(current.arch),
         count: pending.count,
         longestMs: pending.longestMs,
+        day: recent.length,
+        phase: context.phase,
+        uptime: context.uptime,
+        gap: context.gap,
+        ...(context.attention ? { active: context.attention.active, visible: context.attention.visible } : {}),
+        ...(event.sqlite && section.startsWith("sqlite.blocked")
+          ? { attempts: Math.max(1, Math.min(99, Math.round(event.sqlite.attempts))), lockWait: event.sqlite.lockWait }
+          : {}),
       });
     }
     current.save(state);
@@ -208,7 +375,16 @@ export function installStallReporter(next: StallReporterHost): () => void {
   };
 }
 
+/** How the desktop app's Bun process tells whether anyone was looking when it froze (bun/window/attention.ts). */
+export function setStallAttentionProbe(next: (() => StallAttention) | null): () => void {
+  attentionProbe = next;
+  return () => {
+    if (attentionProbe === next) attentionProbe = null;
+  };
+}
+
 /** Test seam. */
 export function resetStallReporterForTests(): void {
   host = null;
+  attentionProbe = null;
 }

package/src/test-support/outage.ts

@@ -0,0 +1,8 @@
+/**
+ * A request that never reached its server, with `message`: the failure a
+ * saved copy answers for (`isTransientFailure`), unlike a plain `Error`, which
+ * reads as a reply that failed validation.
+ */
+export function outage(message = "Unable to connect. Is the computer able to access the url?"): Error {
+  return Object.assign(new Error(message), { code: "ConnectionRefused" });
+}