gloomberb 0.18.2 → 0.18.4

package/src/renderers/electrobun/view/fatal-screen.tsx

@@ -21,7 +21,7 @@ function formatFatalError(error: unknown, details?: string): string {
 }
 
 export function DesktopFatalScreen({
-  title = "Gloomberb crashed",
+  title = "Gloom crashed",
   error,
   details,
   source,

package/src/renderers/electrobun/view/main.tsx

@@ -26,6 +26,7 @@ import { installElectrobunUpdateHost } from "./update-host";
 import { installScreenshotWatermark } from "./screenshot-watermark";
 import { installElectrobunWindowFullscreenTracking } from "./window-fullscreen";
 import { installDomMarketDataFrames } from "../../dom/data-frames";
+import { releaseBootFrameWhenDrawn, startBootFrameRecorder } from "../../dom/boot-frame";
 import { DomErrorBoundary, DomHostProviders } from "../../dom/dom-host-providers";
 import { DesktopFatalScreen } from "./fatal-screen";
 import { resolveRendererWindowError } from "./renderer-window-error";
@@ -45,6 +46,7 @@ import { getMarketplaceHost, setPluginManager, type PluginManager } from "../../
 import { remoteNotesFilesIO, setNotesFilesIO } from "../../../plugins/builtin/notes/files";
 import { NOTES_FILES_CAPABILITY_ID } from "../../../capabilities";
 import { loadOfficialPluginIds } from "../../../plugins/marketplace/feed";
+import { setPluginSeedNotice } from "../../../plugins/seed-notice";
 import { crashReportsEnabled, installCrashReporter, reportCrash } from "../../../telemetry/crash-reports";
 import { browserDoNotTrack, installWindowCrashListeners } from "../../../telemetry/crash-reports-dom";
 import { currentTelemetryConfig } from "../../../telemetry/live-config";
@@ -72,9 +74,14 @@ const bootLog = debugLog.createLogger("electrobun-web-boot");
 let appMounted = false;
 
 appRootElement.tabIndex = -1;
-root.render(<div className="gloom-loading">Starting Gloomberb...</div>);
+// The page drew the layout this window last drew, or the bare shell, before
+// this script loaded (dom/boot-frame.ts); it stays until the app has drawn its own.
+const releaseBootFrame = releaseBootFrameWhenDrawn(document, appRootElement);
+/** How long after the app mounts the launch frame stays at most. */
+const BOOT_FRAME_RELEASE_FALLBACK_MS = 4_000;
 
-function renderFatalError(error: unknown, details?: string, title = "Gloomberb failed to start"): void {
+function renderFatalError(error: unknown, details?: string, title = "Gloom failed to start"): void {
+  releaseBootFrame();
   root.render(
     <DesktopFatalScreen
       title={title}
@@ -94,7 +101,7 @@ window.__gloomRenderFatalError = (error, details, source) => {
   }) === "ignore") {
     return;
   }
-  renderFatalError(error, details, "Gloomberb crashed");
+  renderFatalError(error, details, "Gloom crashed");
 };
 
 function focusWebSurface(): void {
@@ -113,9 +120,13 @@ function requestStartupFocus(): void {
 
 async function boot() {
   bootLog.info("boot started");
+  // Both asked for at once: the Bun process compiles the plugins while it
+  // answers `init`, rather than after this view asks a second time.
   const backendInitPromise = initElectrobunBackend();
+  const externalBundlesPromise = backendRequest("plugins.listExternal");
   // Avoid a premature global unhandled-rejection render while UI chunks load.
   void backendInitPromise.catch(() => {});
+  void externalBundlesPromise.catch(() => {});
 
   installElectrobunConfigStoreHost();
   installElectrobunBrokerRemoteClient();
@@ -156,6 +167,8 @@ async function boot() {
     : init.desktopSnapshot;
   const config = desktopSnapshot?.config ?? init.config;
   applyLanguageFromConfig(config);
+  // Said by the app once it is up, as the terminal says it.
+  setPluginSeedNotice(init.pluginSeedNotice ?? null);
   const desktopWindowBridge = createDesktopWindowBridge(init.windowKind, init.paneId);
   const desktopApplicationMenuBridge: DesktopApplicationMenuBridge = {
     subscribe: (listener) => onBackendMessage("application-menu.select", ({ command }) => listener(command)),
@@ -172,7 +185,11 @@ async function boot() {
     "startup.electrobun.load-external-plugins",
     async () => {
       try {
-        return await loadDesktopExternalPlugins(await backendRequest("plugins.listExternal"));
+        // Asked once more if the early request failed: it waits for the
+        // whole launch, which a first run's plugin downloads can stretch past
+        // the request's time limit.
+        const bundles = await externalBundlesPromise.catch(() => backendRequest("plugins.listExternal"));
+        return await loadDesktopExternalPlugins(bundles);
       } catch (error) {
         debugLog.createLogger("desktop-plugins").error(`External plugin load failed: ${error}`);
         return [];
@@ -245,6 +262,15 @@ async function boot() {
     );
     appMounted = true;
   });
+  // A layout with neither panes nor a status bar has nothing to wait for.
+  window.setTimeout(releaseBootFrame, BOOT_FRAME_RELEASE_FALLBACK_MS);
+  if (init.windowKind === "main") {
+    startBootFrameRecorder({
+      doc: document,
+      root: appRootElement,
+      save: (frame) => { void backendRequest("host.saveBootFrame", { frame }).catch(() => {}); },
+    });
+  }
   requestStartupFocus();
   bootLog.info("root render scheduled", {
     layoutPanes: config.layout.instances.length,

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

@@ -1,15 +1,16 @@
 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 { cloudNewsReadArticles, mapCloudNewsArticle, readCloudNews } from "../../../sources/gloomberb-cloud/news";
+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">;
+type CloudNewsClient = Pick<typeof apiClient, "getCloudNews" | "getCloudNewsStory" | "searchCloudNews">;
 
 /**
  * The view's only news source: the desktop view runs without capability
@@ -27,13 +28,14 @@ export function createDesktopNewsSource(backend: BackendNews, client: CloudNewsC
       fetchNews: (query) => backend.getNews(query),
       fetchNewsPage: async (query) => {
         try {
-          const response = await client.getCloudNews(cloudNewsParams(query));
+          const read = await readCloudNews(client, query);
           return {
-            articles: response.items.map((item) => mapCloudNewsArticle(item, query.ticker)),
-            nextCursor: response.nextCursor ?? null,
+            articles: cloudNewsReadArticles(read, query.ticker),
+            nextCursor: read.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"]>;
 }
 
@@ -119,7 +121,7 @@ export function createRemoteAssetDataClient(): RemoteAssetDataClient {
 
   const base: RemoteAssetDataClientBase = {
     id: "desktop-backend",
-    name: "Gloomberb Backend",
+    name: "Gloom Backend",
     getCachedFinancialsForTargets: (targets, options) => (
       hasRendererOperation(assetDataOperations, "getCachedFinancialsForTargets")
         ? invoke<Map<string, TickerFinancials>>(ASSET_DATA_CAPABILITY_ID, "getCachedFinancialsForTargets", { targets, options })
@@ -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/electrobun/view/ui-host.tsx

@@ -33,7 +33,7 @@ export const webRendererHost: RendererHost = {
     await backendRequest("host.windowControl", { action });
   },
   async openExternal(url) {
-    await backendRequest("host.openExternal", { url });
+    return await backendRequest("host.openExternal", { url });
   },
   async copyText(text) {
     try {

package/src/renderers/opentui/browser-open.ts

@@ -0,0 +1,88 @@
+/**
+ * Opening a link in a browser the person can see, from a terminal. The
+ * terminal often runs somewhere else: over SSH, a browser started on that
+ * machine shows on its screen or nowhere, and `open` or `xdg-open` still
+ * report success. Those cases get no command at all, so the caller knows
+ * nothing opened and can show the link instead.
+ */
+
+type Env = Readonly<Record<string, string | undefined>>;
+
+function present(value: string | undefined): boolean {
+  return !!value?.trim();
+}
+
+/**
+ * The command `$BROWSER` names, with the link in it. Editors with a remote
+ * terminal (VS Code over SSH, Codespaces) point it at a helper that opens the
+ * link on the person's own machine. A `:` separated list takes its first entry.
+ */
+function envBrowserCommand(browser: string, url: string): string[] | null {
+  const entry = browser.split(":")[0]?.trim();
+  if (!entry) return null;
+  const parts = entry.split(/\s+/);
+  return parts.some((part) => part.includes("%s"))
+    ? parts.map((part) => part.replaceAll("%s", url))
+    : [...parts, url];
+}
+
+/**
+ * The commands to try in order, each with the link as its last argument.
+ * Empty when this terminal cannot show a browser to the person using it.
+ */
+export function browserOpenCommands(url: string, env: Env, platform: NodeJS.Platform): string[][] {
+  const remote = present(env.SSH_CONNECTION) || present(env.SSH_CLIENT) || present(env.SSH_TTY);
+  const forwarded = present(env.BROWSER) ? envBrowserCommand(env.BROWSER!, url) : null;
+
+  if (platform === "darwin") {
+    if (!remote) return [["open", url]];
+    return forwarded ? [forwarded] : [];
+  }
+  if (platform === "win32") {
+    if (!remote) return [["cmd", "/c", "start", "", url]];
+    return forwarded ? [forwarded] : [];
+  }
+
+  // Linux and the other unixes. WSL has no Linux browser, but Windows can
+  // open the link: `wslview` when wslu is installed, else Windows' own handler.
+  if (present(env.WSL_DISTRO_NAME) || present(env.WSL_INTEROP)) {
+    return [
+      ...(forwarded ? [forwarded] : []),
+      ["wslview", url],
+      ["rundll32.exe", "url.dll,FileProtocolHandler", url],
+    ];
+  }
+  const display = present(env.DISPLAY) || present(env.WAYLAND_DISPLAY);
+  // xdg-open reads $BROWSER itself, so a forwarding helper still applies.
+  if (remote && !display && !forwarded) return [];
+  return [["xdg-open", url]];
+}
+
+/** How long an opener may run before it counts as having opened the browser. */
+const OPENER_SETTLE_MS = 5_000;
+
+/**
+ * Runs one opener. Exit 0 opened the link; a missing command or another exit
+ * code did not. An opener still running after a few seconds is a browser
+ * started in the foreground of the command, which has opened the link.
+ */
+export async function runBrowserOpener(command: string[]): Promise<boolean> {
+  try {
+    const proc = Bun.spawn(command, { stdin: "ignore", stdout: "ignore", stderr: "ignore" });
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    const settled = new Promise<"running">((resolve) => {
+      timer = setTimeout(() => resolve("running"), OPENER_SETTLE_MS);
+      timer.unref?.();
+    });
+    const result = await Promise.race([proc.exited, settled]);
+    clearTimeout(timer);
+    if (result === "running") {
+      proc.unref();
+      return true;
+    }
+    return result === 0;
+  } catch {
+    // The command is not installed (xdg-open is missing on minimal Linux).
+    return false;
+  }
+}

package/src/renderers/opentui/host.tsx

@@ -6,6 +6,7 @@ import type { KeyEventLike } from "../../react/input";
 import type { NativeRendererHost, PixelResolution, RendererHost } from "../../ui/host";
 import { colors } from "../../theme/colors";
 import { safeExternalUrl } from "../../utils/external-url";
+import { browserOpenCommands, runBrowserOpener } from "./browser-open";
 import { buildTerminalMediaArgs, createTerminalMediaReaper, terminalMediaStateFile } from "./terminal-media";
 import { saveTextFileToDownloads } from "../../utils/save-text-file";
 import { installInteractionPerformanceRecorder } from "./interaction-performance";
@@ -129,23 +130,13 @@ export async function createOpenTuiHost(): Promise<OpenTuiHost> {
     requestExit: () => renderer.destroy(),
     async openExternal(rawUrl) {
       const url = safeExternalUrl(rawUrl);
-      if (!url) return;
-      const command = process.platform === "darwin"
-        ? ["open", url]
-        : process.platform === "win32"
-          ? ["cmd", "/c", "start", "", url]
-          : ["xdg-open", url];
-      try {
-        const proc = Bun.spawn(command, {
-          stdout: "ignore",
-          stderr: "ignore",
-        });
-        if (await proc.exited === 0) return;
-      } catch {
-        // No opener installed (xdg-open is missing on minimal Linux and WSL).
+      if (!url) return false;
+      for (const command of browserOpenCommands(url, process.env, process.platform)) {
+        if (await runBrowserOpener(command)) return true;
       }
       // Leave the link on the clipboard, so it can at least be pasted.
       renderer.copyToClipboardOSC52(url);
+      return false;
     },
     async copyText(text) {
       if (!text) return;

package/src/renderers/opentui/image/loader.ts

@@ -1,4 +1,3 @@
-import { Jimp } from "jimp";
 import type { NativeChartBitmap } from "../../../components/chart/native/chart-rasterizer";
 
 type ImageObjectFit = "contain" | "cover";
@@ -67,7 +66,9 @@ function loadSourceImage(src: string): Promise<JimpImageLike> {
   if (cached) return cached;
 
   const promise = fetchImageBytes(src)
-    .then((bytes) => Jimp.read(bytes))
+    // Loaded with the first image: the decoder is a large part of what the
+    // terminal would otherwise load before it draws anything.
+    .then(async (bytes) => (await import("jimp")).Jimp.read(bytes))
     .then(adaptJimpImage)
     .catch((error) => {
       sourceImageCache.delete(src);

package/src/renderers/opentui/native-smoke.ts

@@ -1 +1,10 @@
-import "@opentui/core";
+import { resolveRenderLib } from "@opentui/core";
+import { loadRenderLib } from "./render-lib";
+
+// Loaded the way a launch loads it, so the smoke covers the cache folder used
+// when the temp folder cannot run the library.
+await loadRenderLib();
+// Importing @opentui/core swallows a render library that fails to load and
+// throws only on first use, so load it here: the glibc library on a musl
+// system fails this way ("getcontext: symbol not found").
+resolveRenderLib();

package/src/renderers/opentui/pane-image/index.ts

@@ -1,5 +1,4 @@
 import type { CliRenderer } from "@opentui/core";
-import { Jimp } from "jimp";
 import type { NativeSurfaceManager } from "../../../components/chart/native/surface/manager";
 import type { CellRect } from "../../../components/chart/native/chart-rasterizer";
 import { intersectCellRects } from "../../../components/chart/native/chart-rasterizer";
@@ -95,6 +94,8 @@ export async function captureTerminalPaneImage(
   const base = hexRgb(background);
   const layers = imageLayers(manager, clipRect(rect, renderer.currentRenderBuffer.width, renderer.currentRenderBuffer.height)!);
   const image = rasterizeFrame(frame, layers, base);
+  // Loaded on the first capture rather than with the terminal.
+  const { Jimp } = await import("jimp");
   const jimp = new Jimp({ width: image.width, height: image.height, data: Buffer.from(image.pixels.buffer, image.pixels.byteOffset, image.pixels.byteLength) });
   const png = await jimp.getBuffer("image/png");
   return {

package/src/renderers/opentui/render-lib.ts

@@ -0,0 +1,253 @@
+/**
+ * Loads OpenTUI's native render library before the terminal starts, and
+ * keeps the standalone binary starting when its temp folder cannot run it.
+ *
+ * A Bun-compiled binary carries the library inside itself. Bun's dlopen
+ * writes it to a new file in the temp folder on every launch and loads that
+ * file. When the folder is full or read-only the write fails and the load
+ * fails on the path inside the binary ("/$bunfs/root/libopentui-*.so: cannot
+ * open shared object file"); when it is mounted noexec the file is written
+ * but cannot be mapped ("failed to map segment from shared object"). Either
+ * way the library is copied once into the native cache folder and loaded
+ * from there on every later launch. The copy is named after the embedded
+ * file, whose name carries a hash of its contents, so an upgrade never loads
+ * an older library.
+ *
+ * Bun never deletes the files it writes, so each launch would leave 8 MB in
+ * the temp folder until it fills up. On Linux the one this launch mapped is
+ * removed once it is loaded: the mapping keeps it usable until exit.
+ */
+import { mkdirSync, readdirSync, readFileSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "fs";
+import { basename, dirname, join } from "path";
+import { getGloomberbDirs } from "../../data/config/home";
+
+/** Where the render library sits inside a standalone binary. */
+interface EmbeddedRenderLib {
+  /** The library @opentui/core loads by default. */
+  path: string;
+  /** Linux: the musl library, which it loads instead when `OPENTUI_LIBC` is `musl`. */
+  musl?: string;
+}
+
+let embeddedRenderLib: EmbeddedRenderLib | null = null;
+
+/**
+ * Where the standalone binary carries its render library. A package or a
+ * checkout has none.
+ * @knipignore Called by the module scripts/build.ts writes for the release binary.
+ */
+export function useEmbeddedRenderLib(lib: EmbeddedRenderLib): void {
+  embeddedRenderLib = lib;
+}
+
+/** The embedded library @opentui/core picks, by the same rule it uses. */
+function embeddedRenderLibPath(env: NodeJS.ProcessEnv): string | null {
+  if (!embeddedRenderLib) return null;
+  return env.OPENTUI_LIBC === "musl" && embeddedRenderLib.musl ? embeddedRenderLib.musl : embeddedRenderLib.path;
+}
+
+/**
+ * The folder Bun writes embedded libraries to before loading them: a
+ * non-empty `BUN_TMPDIR`, else `TMPDIR`, `TMP` or `TEMP`, else the platform's
+ * (Bun 1.3, `RealFS.tmpdirPath`).
+ */
+function bunTempDir(env: NodeJS.ProcessEnv, platform: NodeJS.Platform): string {
+  const dir = env.BUN_TMPDIR || env.TMPDIR || env.TMP || env.TEMP;
+  if (dir) return dir.length > 1 && /[\\/]$/.test(dir) ? dir.slice(0, -1) : dir;
+  if (platform === "darwin") return "/private/tmp";
+  if (platform === "win32") return `${(env.SYSTEMROOT || env.WINDIR || "C:\\Windows").replace(/\\$/, "")}\\Temp`;
+  return "/tmp";
+}
+
+/** How Bun names the copy it writes: `.<hex>-<HEX>.so` (`.dylib`, `.dll`). */
+const BUN_EXTRACTED_NAME = /^\.[0-9a-f]+-[0-9A-F]+\.(?:so|dylib|dll)$/;
+
+/**
+ * The temp folder copies this process has mapped, read from
+ * `/proc/self/maps`: `address perms offset dev inode path`, with
+ * ` (deleted)` after a path that is gone.
+ */
+function mappedExtractedCopies(maps: string, tempDir: string): string[] {
+  const copies = new Set<string>();
+  for (const line of maps.split("\n")) {
+    const path = /^\S+\s+\S+\s+\S+\s+\S+\s+\S+\s+(\/.*)$/.exec(line)?.[1];
+    if (!path || path.endsWith(" (deleted)")) continue;
+    if (dirname(path) === tempDir && BUN_EXTRACTED_NAME.test(basename(path))) copies.add(path);
+  }
+  return [...copies];
+}
+
+/**
+ * Copies of the library Bun wrote to the temp folder during this launch and
+ * could not load: a noexec folder holds a whole copy for every attempt, a
+ * full one a cut-off copy. Matched by Bun's naming, a size up to the
+ * library's and a write time after this process started.
+ */
+function failedExtractedCopies(tempDir: string, size: number, sinceMs: number): string[] {
+  return listDir(tempDir).filter((name) => BUN_EXTRACTED_NAME.test(name)).map((name) => join(tempDir, name)).filter((path) => {
+    try {
+      const stat = statSync(path);
+      return stat.isFile() && stat.size <= size && stat.mtimeMs >= sinceMs;
+    } catch {
+      // Intentional ignore: a copy that vanished needs no removal.
+      return false;
+    }
+  });
+}
+
+function listDir(dir: string): string[] {
+  try {
+    return readdirSync(dir);
+  } catch {
+    // Intentional ignore: an unreadable folder holds nothing we could remove.
+    return [];
+  }
+}
+
+function removeFiles(paths: readonly string[]): void {
+  for (const path of paths) {
+    try {
+      rmSync(path, { force: true });
+    } catch {
+      // Intentional ignore: a copy left behind only costs disk space.
+    }
+  }
+}
+
+/** Puts the embedded library in the cache folder unless an intact copy is there, and returns its path. */
+function cachedCopy(embeddedPath: string, size: number, cacheDir: string): string {
+  const name = basename(embeddedPath);
+  const target = join(cacheDir, name);
+  try {
+    if (statSync(target).size === size) return target;
+  } catch {
+    // Intentional ignore: no copy yet, written below.
+  }
+  mkdirSync(cacheDir, { recursive: true });
+  const partial = join(cacheDir, `.${name}.${process.pid}.partial`);
+  try {
+    writeFileSync(partial, readFileSync(embeddedPath), { mode: 0o755 });
+    renameSync(partial, target);
+  } catch (error) {
+    removeFiles([partial]);
+    throw error;
+  }
+  // The copy an earlier version left, now unused. Another launch's partial
+  // copy (dot-named) is still being written and stays.
+  removeFiles(listDir(cacheDir).filter((entry) => entry !== name && entry.startsWith("libopentui")).map((entry) => join(cacheDir, entry)));
+  return target;
+}
+
+/**
+ * A failed load the folder the library was in explains: it never left the
+ * binary because the temp folder took no file (`$bunfs`, `~BUN` on Windows),
+ * or the folder does not let code run from it (glibc: "failed to map
+ * segment", musl: "Operation not permitted"). A missing symbol or dependency
+ * fails wherever the file sits.
+ */
+function isFolderFailure(error: unknown): boolean {
+  const message = error instanceof Error ? error.message : String(error);
+  return /\$bunfs|~BUN|failed to map segment|operation not permitted|permission denied/i.test(message);
+}
+
+/** Neither the temp folder nor the cache folder can hold and run the library. */
+export class RenderLibUnavailableError extends Error {
+  constructor(tempDir: string, cacheDir: string) {
+    super(
+      `Gloom can't load its render library: neither the temp folder ${tempDir} nor ${cacheDir} can hold and run it. `
+      + "Start it with TMPDIR set to a writable folder that allows running programs: TMPDIR=/path/to/folder gloom",
+    );
+    this.name = "RenderLibUnavailableError";
+  }
+}
+
+export interface RenderLibLoadOptions {
+  /** Points @opentui/core at a library file (undefined: the one it picks) and loads it, throwing what loading threw. */
+  load(path?: string): void;
+  /** The library inside a standalone binary; null for a package or a checkout. */
+  embeddedPath: string | null;
+  tempDir: string;
+  cacheDir: string;
+  /** `/proc/self/maps`, or null where there is none. */
+  readMaps(): string | null;
+  /** When this process started, in epoch milliseconds. */
+  startedAtMs: number;
+}
+
+/**
+ * Loads the library from the temp folder, and from the cache folder when
+ * the temp folder cannot hold or run it. Anything this cannot help with is
+ * left as it was: the terminal then fails on it where it always did.
+ * Throws {@link RenderLibUnavailableError} when both folders fail.
+ */
+export function loadRenderLibWith(options: RenderLibLoadOptions): void {
+  const { load, embeddedPath, tempDir, cacheDir } = options;
+  let tempError: unknown;
+  try {
+    load();
+    if (embeddedPath) removeFiles(mappedExtractedCopies(options.readMaps() ?? "", realPath(tempDir)));
+    return;
+  } catch (error) {
+    if (!embeddedPath) return;
+    tempError = error;
+  }
+
+  let size: number;
+  try {
+    size = statSync(embeddedPath).size;
+  } catch {
+    // Intentional ignore: without the embedded file there is nothing to copy, so the original failure stands.
+    return;
+  }
+  // The margin allows for file systems with coarse times.
+  removeFiles(failedExtractedCopies(tempDir, size, options.startedAtMs - 2_000));
+
+  let cachePath: string;
+  try {
+    cachePath = cachedCopy(embeddedPath, size, cacheDir);
+  } catch {
+    // The cache folder cannot hold it either. Only the temp folder's fault is reported as such.
+    if (isFolderFailure(tempError)) throw new RenderLibUnavailableError(tempDir, cacheDir);
+    return;
+  }
+  try {
+    load(cachePath);
+  } catch (cacheError) {
+    if (isFolderFailure(tempError) && isFolderFailure(cacheError)) throw new RenderLibUnavailableError(tempDir, cacheDir);
+  }
+}
+
+function realPath(path: string): string {
+  try {
+    return realpathSync(path);
+  } catch {
+    // Intentional ignore: a temp folder that does not resolve holds nothing mapped.
+    return path;
+  }
+}
+
+function readProcessMaps(): string | null {
+  if (process.platform !== "linux") return null;
+  try {
+    return readFileSync("/proc/self/maps", "utf8");
+  } catch {
+    // Intentional ignore: without /proc the copy stays, as it always did.
+    return null;
+  }
+}
+
+/** Loads the render library for this process; see {@link loadRenderLibWith}. */
+export async function loadRenderLib(): Promise<void> {
+  const { resolveRenderLib, setRenderLibPath } = await import("@opentui/core");
+  loadRenderLibWith({
+    load(path) {
+      if (path) setRenderLibPath(path);
+      resolveRenderLib();
+    },
+    embeddedPath: embeddedRenderLibPath(process.env),
+    tempDir: bunTempDir(process.env, process.platform),
+    cacheDir: getGloomberbDirs().nativeCache,
+    readMaps: readProcessMaps,
+    startedAtMs: performance.timeOrigin,
+  });
+}

package/src/renderers/opentui/render-timing-smoke.ts

@@ -3,7 +3,7 @@ import { testRender } from "@opentui/react/test-utils";
 
 /**
  * A global install runs react-reconciler without its patch (see
- * bin/gloomberb). If the dev build's user timing turns back on, every render
+ * bin/gloom). If the dev build's user timing turns back on, every render
  * adds a performance.measure entry that Bun never frees (#452).
  */
 export async function assertRendersLeaveNoTimingEntries(): Promise<void> {

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";
@@ -57,7 +60,7 @@ export async function startOpenTuiApp({ externalPlugins, cliLaunchRequest }: Sta
   debugLog.interceptConsole();
 
   const appLog = debugLog.createLogger("app");
-  appLog.info("Gloomberb starting");
+  appLog.info("Gloom starting");
   const remoteControlAdapter: RemoteControlAdapter = {
     terminalDevice: { kind: "tui", name: hostname() },
     startServer: ({ dataDir, handle }) => {
@@ -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(),