gloomberb 0.18.3 → 0.18.4

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

@@ -60,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 }) => {

package/src/renderers/share/layout-view.tsx

@@ -108,7 +108,7 @@ export function LayoutShareView({
   return (
     <main className="layout-share wide">
       <header>
-        <p className="eyebrow">Shared via Gloomberb</p>
+        <p className="eyebrow">Shared via Gloom</p>
         <h1>{entry.name}</h1>
         <p className="layout-meta">{[author, date, `${entry.layout.instances.length} panes`].filter(Boolean).join(" · ")}</p>
       </header>
@@ -126,7 +126,7 @@ export function LayoutShareView({
 
       <div className="handoff">
         <a className="cta" href={openLiveUrl}>Use this layout</a>
-        <p className="descriptor">Opens in Gloomberb as an independent, editable copy.</p>
+        <p className="descriptor">Opens in Gloom as an independent, editable copy.</p>
       </div>
     </main>
   );

package/src/renderers/share/main.tsx

@@ -40,7 +40,7 @@ function LayoutApp({ id }: { id: string }) {
 
   return state.entry
     ? <LayoutShareView entry={state.entry} openLiveUrl={openLiveMarketplaceLayoutUrl(id)} />
-    : <main><h1>Gloomberb</h1><p>{state.error ?? "Loading shared layout..."}</p></main>;
+    : <main><h1>Gloom</h1><p>{state.error ?? "Loading shared layout..."}</p></main>;
 }
 
 function ContentShareApp({ id }: { id: string }) {
@@ -91,18 +91,18 @@ function ContentShareApp({ id }: { id: string }) {
       />
     );
   }
-  return <main><h1>Gloomberb</h1><p>{state.error ?? "Loading shared view..."}</p></main>;
+  return <main><h1>Gloom</h1><p>{state.error ?? "Loading shared view..."}</p></main>;
 }
 
 function SocialShareApp() {
   const pathname = window.location.pathname;
   const layoutId = parseMarketplaceLayoutId(pathname);
   if (layoutId) return <LayoutApp id={layoutId} />;
-  if (pathname.startsWith("/l/")) return <main><h1>Gloomberb</h1><p>Invalid layout link.</p></main>;
+  if (pathname.startsWith("/l/")) return <main><h1>Gloom</h1><p>Invalid layout link.</p></main>;
   const shareId = parseShareId(pathname);
   return shareId
     ? <ContentShareApp id={shareId} />
-    : <main><h1>Gloomberb</h1><p>Invalid share link.</p></main>;
+    : <main><h1>Gloom</h1><p>Invalid share link.</p></main>;
 }
 
 const root = document.getElementById("root");

package/src/renderers/share/view.tsx

@@ -89,7 +89,7 @@ export function ShareView({
     return (
       <main className="pane">
         <header>
-          <p className="eyebrow">Shared via Gloomberb</p>
+          <p className="eyebrow">Shared via Gloom</p>
           <h1>{share.data.title}</h1>
           {share.data.description ? <p className="pane-description">{share.data.description}</p> : null}
         </header>

package/src/series/resolve.ts

@@ -6,7 +6,8 @@ import type {
   SeriesPeriod,
   TimeSeriesPoint,
 } from "../time-series/types";
-import { getPresetResolution, type ManualChartResolution } from "../time-series/resolution";
+import { chartBarSizeSource, getPresetResolution, isCustomChartResolution } from "../time-series/resolution";
+import { futuresSessionOpenMinute } from "../market-data/market/trading-sessions";
 import { SERIES_COLORS } from "../theme/series-colors";
 import type {
   LoadedSeriesDefinition,
@@ -74,9 +75,24 @@ function seriesColor(id: string, lineIndex = 0): string {
   return SERIES_COLORS[(hash + lineIndex) % SERIES_COLORS.length]!;
 }
 
-/** The bar size a chart draws prices in: the one it was set to, else its range's default. */
-function viewportResolution(viewport: ChartViewportSpec): ManualChartResolution {
-  return viewport.resolution === "auto" ? getPresetResolution(viewport.range) : viewport.resolution;
+/**
+ * The bars a chart draws prices in, as a load request states them: the bar
+ * size it was set to, else its range's default. A size the source does not
+ * serve (4h) goes as the source bars it is built from (`resolution: 1h`) and
+ * the size itself (`barSize: 4h`), so a series that knows only the source
+ * sizes still gets one it knows.
+ */
+function viewportBars(viewport: ChartViewportSpec, ticker: string | undefined): Pick<SeriesLoadRequest, "resolution" | "barSize"> {
+  if (viewport.resolution === "auto") return { resolution: getPresetResolution(viewport.range) };
+  if (!isCustomChartResolution(viewport.resolution)) return { resolution: viewport.resolution };
+  const openMinute = ticker ? futuresSessionOpenMinute(splitTicker(ticker).symbol, splitTicker(ticker).exchange) : null;
+  return { resolution: chartBarSizeSource(viewport.resolution, [], openMinute), barSize: viewport.resolution };
+}
+
+/** `NESN:XSWX` as its symbol and listing. */
+function splitTicker(ticker: string): { symbol: string; exchange: string } {
+  const colon = ticker.lastIndexOf(":");
+  return colon > 0 ? { symbol: ticker.slice(0, colon), exchange: ticker.slice(colon + 1) } : { symbol: ticker, exchange: "" };
 }
 
 /** The dates a chart viewport covers, as a series load request takes them. */
@@ -133,7 +149,7 @@ function loadSeries(definition: LoadedSeriesDefinition, request: SeriesLoadReque
   if (signal?.aborted) return Promise.reject(signal.reason);
   // A window measured back from now moves by milliseconds between the lines' requests.
   const minute = (date: Date | undefined) => date ? Math.floor(date.getTime() / 60_000) : null;
-  const key = JSON.stringify([shared.ticker ?? null, minute(shared.start), minute(shared.end), shared.resolution ?? null]);
+  const key = JSON.stringify([shared.ticker ?? null, minute(shared.start), minute(shared.end), shared.resolution ?? null, shared.barSize ?? null]);
   let byKey = sharedLoads.get(definition);
   if (!byKey) sharedLoads.set(definition, byKey = new Map());
   let load = byKey.get(key);
@@ -182,7 +198,7 @@ export async function resolveLoadedSeries(
   const { points, edge, warning, attribution } = loadResult(await loadSeries(definition, {
     ...seriesLoadWindow(request.viewport, now),
     ...(ticker ? { ticker } : {}),
-    resolution: viewportResolution(request.viewport),
+    ...viewportBars(request.viewport, ticker),
     ...(request.signal ? { signal: request.signal } : {}),
   }), line);
   const seriesId = ticker ? `${definition.id}/${ticker}` : definition.id;

package/src/series/standalone.ts

@@ -4,11 +4,12 @@ import type { CapabilityInvoker } from "../capabilities/types";
 import type { GloomPlugin } from "../types/plugin";
 import { resolveRegisteredSeries } from "./capability";
 import { readSeriesFolder } from "./files";
-import { SeriesRegistry } from "./registry";
+import { SeriesRegistry, seriesExpression } from "./registry";
+import type { SeriesDefinition } from "./types";
 
 /**
  * Charts the catalog's loaded series where no plugin runtime runs, such as a
- * `gloomberb fn G` report: the series plugins declare, and the files in the
+ * `gloom fn G` report: the series plugins declare, and the files in the
  * data directory's series folder. Series a plugin registers from its setup
  * need the app.
  */
@@ -47,3 +48,30 @@ export function standaloneSeriesInvoker(
     },
   };
 }
+
+/**
+ * The plugins' catalog series by what `fn G` charts each as (`FRED:DFII10`),
+ * where no plugin runtime runs: a series with an input (a ticker's field) is
+ * no one expression. The first plugin to declare an expression keeps it, as
+ * the registry's `findByExpression` does.
+ */
+export function standaloneSeriesCatalog(
+  plugins: readonly GloomPlugin[],
+  disabledPlugins: readonly string[] = [],
+): (expression: string) => SeriesDefinition | undefined {
+  let byExpression: Map<string, SeriesDefinition> | null = null;
+  return (expression) => {
+    if (!byExpression) {
+      byExpression = new Map();
+      for (const plugin of plugins) {
+        if (disabledPlugins.includes(plugin.id)) continue;
+        for (const definition of plugin.series ?? []) {
+          if (definition.input) continue;
+          const key = seriesExpression(definition);
+          if (!byExpression.has(key)) byExpression.set(key, definition);
+        }
+      }
+    }
+    return byExpression.get(expression);
+  };
+}

package/src/series/types.ts

@@ -6,7 +6,7 @@
  * either loads its own history (`load`) or points at something the composer
  * already draws (`expression`), such as a FRED series or a ticker field.
  */
-import type { ManualChartResolution } from "../time-series/resolution";
+import type { ChartBarSize, ManualChartResolution } from "../time-series/resolution";
 
 /** How often a series gets a new observation. */
 export type SeriesFrequency =
@@ -72,6 +72,13 @@ export interface SeriesLoadRequest {
    * bars uses it to compute on the same bars.
    */
   resolution?: ManualChartResolution;
+  /**
+   * Set when the chart builds its bars from `resolution` bars rather than
+   * drawing those (`4h` from `1h`, `2d` from `1d`): the bar size it draws. A
+   * series computed from a ticker's bars builds them the same way with
+   * `aggregatePriceBars`, so its points fall on the chart's bars.
+   */
+  barSize?: ChartBarSize;
   signal?: AbortSignal;
 }
 

package/src/shares/api.ts

@@ -1,4 +1,5 @@
 import { ApiRequestError } from "../api-client/errors";
+import { DataServiceUnreachableError } from "../utils/network-failure";
 import { parseSharePayload, type SharePayload } from "./payload";
 
 declare const __GLOOMBERB_API_URL__: string | undefined;
@@ -36,11 +37,13 @@ function validDate(value: unknown): value is string {
  * A request that never got an answer, in the words of whichever fetch made
  * it: a browser's ("Failed to fetch", Safari's "Load failed", Firefox's
  * "NetworkError ..."), Bun's ("Unable to connect ...", which the desktop
- * relays from its Bun process as a plain message), or a timeout.
+ * relays from its Bun process as a plain message), the Cloud client's
+ * `DataServiceUnreachableError` for any of them, or a timeout.
  */
 const NETWORK_FAILURE = /failed to fetch|load failed|networkerror|network connection was lost|appears to be offline|fetch failed|unable to connect|socket connection was closed|typo in the url or port|timed out/i;
 
 function isNetworkFailure(error: unknown): boolean {
+  if (error instanceof DataServiceUnreachableError) return true;
   if (!error || typeof error !== "object") return false;
   const { name, message } = error as { name?: unknown; message?: unknown };
   return name === "AbortError" || name === "TimeoutError" || (typeof message === "string" && NETWORK_FAILURE.test(message));

package/src/shares/pane.ts

@@ -53,7 +53,7 @@ export async function openPaneShare(
     return;
   }
   const template = pluginRegistry.paneTemplates.get(share.templateId);
-  if (!template?.publicShare) throw new Error("This shared pane is unavailable in this version of Gloomberb.");
+  if (!template?.publicShare) throw new Error("This shared pane is unavailable in this version of Gloom.");
   const options = template.publicShare.restore(share.data);
   if (!options) throw new Error("This shared pane contains invalid settings.");
   await pluginRegistry.createPaneFromTemplateAsync(template.id, options);

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

@@ -68,21 +68,66 @@ const TURKISH_CPI: SeriesNotOnFred = {
   url: "https://www.tcmb.gov.tr/wps/wcm/connect/EN/TCMB+EN/Main+Menu/Statistics/Inflation+Data/Consumer+Prices",
 };
 
+/** IBGE's IPCA (433) and IPCA-15 (7478), as the central bank's SGS republishes them. */
+const brazilianCpi = (code: number): SeriesNotOnFred => ({
+  publisher: "IBGE",
+  via: "the Banco Central do Brasil's SGS",
+  url: `https://www3.bcb.gov.br/sgspub/consultarvalores/telaCvsSelecionarSeries.paint?codigoSerie=${code}`,
+});
+
 const NOT_ON_FRED: Readonly<Record<string, SeriesNotOnFred>> = {
   TURCPIYOY: TURKISH_CPI,
   TURCPIMOM: TURKISH_CPI,
+  BRAIPCAMOM: brazilianCpi(433),
+  BRAIPCA15MOM: brazilianCpi(7478),
+  // NAHB's builder sentiment index as first released, from the economic calendar's actuals.
+  NAHBHMI: {
+    publisher: "NAHB",
+    via: "the economic calendar",
+    url: "https://www.nahb.org/news-and-economics/housing-economics/indices/housing-market-index",
+  },
+};
+
+/** A series Gloom Cloud computes from two of FRED's, the first less the second, and how. */
+interface ComputedFromFred {
+  legs: readonly [string, string];
+  note: string;
+}
+
+const COMPUTED_FROM_FRED: Readonly<Record<string, ComputedFromFred>> = {
+  MORTGAGE30US10Y: {
+    legs: ["MORTGAGE30US", "DGS10"],
+    note: "MORTGAGE30US minus DGS10 on each Freddie Mac PMMS date; when the Treasury market is closed that day, the 10-year yield of the session before.",
+  },
 };
 
+/** How a series Gloom Cloud computes from FRED's is computed, for the note under its table; null for any other. */
+export function computedFredSeriesNote(seriesId: string): string | null {
+  return COMPUTED_FROM_FRED[seriesId.trim().toUpperCase()]?.note ?? null;
+}
+
 /** The publisher of a served series FRED does not carry; null for FRED's own. */
 export function seriesNotOnFred(seriesId: string): SeriesNotOnFred | null {
   return NOT_ON_FRED[seriesId.trim().toUpperCase()] ?? null;
 }
 
-/** The series' page on the FRED site, where its notes and release schedule live, or its publisher's page when FRED does not carry it. */
+/**
+ * The series' page on the FRED site, where its notes and release schedule
+ * live; FRED's graph of both legs for a series computed from two; its
+ * publisher's page when FRED does not carry it.
+ */
 export function fredSeriesUrl(seriesId: string): string {
+  const legs = COMPUTED_FROM_FRED[seriesId.trim().toUpperCase()]?.legs;
+  if (legs) return `https://fred.stlouisfed.org/graph/?id=${legs.join(",")}`;
   return seriesNotOnFred(seriesId)?.url ?? `https://fred.stlouisfed.org/series/${seriesId}`;
 }
 
+/** What a source line names a series by: `FRED DGS10`, or the FRED series a computed one comes from (`FRED MORTGAGE30US minus DGS10`). */
+export function fredSourceLabel(seriesId: string): string {
+  const legs = COMPUTED_FROM_FRED[seriesId.trim().toUpperCase()]?.legs;
+  return `FRED ${legs ? legs.join(" minus ") : seriesId}`;
+}
+
 function cacheKey(request: FredSeriesRequest): string {
   const range = [
     request.startDate ? `start=${request.startDate}` : "",