gloomberb 0.19.2 → 0.19.3

package/README.md

@@ -45,7 +45,13 @@ For the terminal on **macOS or Linux**:
 curl -fsSL gloom.sh/install | bash
 ```
 
-The script downloads the prebuilt release from GitHub and checks its SHA-256 against the digest GitHub lists. Apple Silicon Macs get the desktop app and the `gloom` command; Linux and Intel Macs get the standalone binary. It asks for `sudo` only if the destination isn't writable. Prefer to download it yourself? See the [installation guide](docs/installation.md).
+For the terminal on **Windows**, in PowerShell:
+
+```powershell
+irm https://gloom.sh/install.ps1 | iex
+```
+
+The script downloads the prebuilt release from GitHub and checks its SHA-256 against the checksum file the release publishes beside it, installing nothing if they differ. Apple Silicon Macs get the desktop app and the `gloom` command; Linux and Intel Macs get the standalone binary. The PowerShell line does the same on Windows: it puts the standalone `gloom.exe` in `%USERPROFILE%\.local\bin` and adds that folder to your PATH. It asks for `sudo` only if the destination isn't writable. Prefer to download it yourself? See the [installation guide](docs/installation.md).
 
 With [Bun](https://bun.sh), on any supported OS:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gloomberb",
-  "version": "0.19.2",
+  "version": "0.19.3",
   "packageManager": "bun@1.3.11",
   "description": "Market research and portfolio tracker for the terminal",
   "module": "src/public/index.ts",

package/patches/electrobun@1.18.1.patch

@@ -495,7 +495,7 @@ index a7822d85c187c1edf361f2e65757057aad9da7b0..533d431c6cc2097951f421cb1fbe3142
  
  async function generateKeyFromBytes(rawKey: Uint8Array): Promise<CryptoKey> {
 diff --git a/dist/api/bun/proc/native.ts b/dist/api/bun/proc/native.ts
-index f0f6c2532ba2eb467ec1d452a25c835b6db72661..ae77cf58d32392ad4cc8e2103ac7ed27baae8bea 100644
+index f0f6c2532ba2eb467ec1d452a25c835b6db72661..3b9cc732f8d71da17e71c019f0930e74d0fb578d 100644
 --- a/dist/api/bun/proc/native.ts
 +++ b/dist/api/bun/proc/native.ts
 @@ -829,6 +829,7 @@ const _ffiImpl = {
@@ -524,3 +524,110 @@ index f0f6c2532ba2eb467ec1d452a25c835b6db72661..ae77cf58d32392ad4cc8e2103ac7ed27
  			if (!hidden) {
  				native_.symbols.showWindow(windowPtr, activate);
  			}
+@@ -1915,6 +1920,14 @@ process.on("SIGTERM", () => {
+ //   }
+ // );
+ 
++// A JSCallback's cstring argument arrives as the pointer under Bun 1.3 and as
++// a string (null for NULL) under Bun 1.4, which Windows builds ship.
++function callbackString(value: unknown): string {
++	if (typeof value === "string") return value;
++	if (value === null || value === undefined) return "";
++	return new CString(value as Pointer).toString();
++}
++
+ const windowCloseCallback = new JSCallback(
+ 	(id) => {
+ 		const handler = electrobunEventEmitter.events.window.close;
+@@ -2036,7 +2049,7 @@ const windowKeyCallback = new JSCallback(
+ 
+ const getMimeType = new JSCallback(
+ 	(filePath) => {
+-		const _filePath = new CString(filePath).toString();
++		const _filePath = callbackString(filePath);
+ 		const mimeType = Bun.file(_filePath).type; // || "application/octet-stream";
+ 
+ 		// For this usecase we generally don't want the charset included in the mimetype
+@@ -2074,7 +2087,7 @@ const globalShortcutHandlers = new Map<string, () => void>();
+ if (native) {
+ 	const urlOpenCallback = new JSCallback(
+ 		(urlPtr) => {
+-			const url = new CString(urlPtr).toString();
++			const url = callbackString(urlPtr);
+ 			const handler = electrobunEventEmitter.events.app.openUrl;
+ 			const event = handler({ url });
+ 			electrobunEventEmitter.emitEvent(event);
+@@ -2111,7 +2124,7 @@ if (native) {
+ 
+ 	const globalShortcutCallback = new JSCallback(
+ 		(acceleratorPtr) => {
+-			const accelerator = new CString(acceleratorPtr).toString();
++			const accelerator = callbackString(acceleratorPtr);
+ 			const handler = globalShortcutHandlers.get(accelerator);
+ 			if (handler) handler();
+ 		},
+@@ -2505,8 +2518,8 @@ const webviewEventJSCallback = new JSCallback(
+ 
+ 		try {
+ 			// Convert cstring pointers to actual strings
+-			eventName = new CString(_eventName).toString();
+-			detail = new CString(_detail).toString();
++			eventName = callbackString(_eventName);
++			detail = callbackString(_detail);
+ 		} catch (err) {
+ 			console.error("[webviewEventJSCallback] Error converting strings:", err);
+ 			console.error("[webviewEventJSCallback] Raw values:", {
+@@ -2528,7 +2541,7 @@ const webviewEventJSCallback = new JSCallback(
+ const bunBridgePostmessageHandler = new JSCallback(
+ 	(id, msg) => {
+ 		try {
+-			const msgStr = new CString(msg);
++			const msgStr = callbackString(msg);
+ 
+ 			if (!msgStr.length) {
+ 				return;
+@@ -2564,7 +2577,7 @@ const bunBridgePostmessageHandler = new JSCallback(
+ const eventBridgeHandler = new JSCallback(
+ 	(_id: number, msg: number) => {
+ 		try {
+-			const message = new CString(msg as unknown as Pointer);
++			const message = callbackString(msg);
+ 			const rawMessage = message.toString().trim();
+ 			if (!rawMessage || (rawMessage[0] !== "{" && rawMessage[0] !== "[")) {
+ 				return;
+@@ -2593,7 +2606,7 @@ const eventBridgeHandler = new JSCallback(
+ const internalBridgeHandler = new JSCallback(
+ 	(_id: number, msg: number) => {
+ 		try {
+-			const batchMessage = new CString(msg as unknown as Pointer);
++			const batchMessage = callbackString(msg);
+ 			const jsonBatch = JSON.parse(batchMessage.toString());
+ 
+ 			if (jsonBatch.id === "webviewEvent") {
+@@ -2664,7 +2677,7 @@ const trayItemHandler = new JSCallback(
+ 	(id, action) => {
+ 		// Note: Some invisible character that doesn't appear in .length
+ 		// is causing issues
+-		const actionString = (new CString(action).toString() || "").trim();
++		const actionString = (callbackString(action) || "").trim();
+ 
+ 		// Use shared deserialization method
+ 		const { action: actualAction, data } = deserializeMenuAction(actionString);
+@@ -2688,7 +2701,7 @@ const trayItemHandler = new JSCallback(
+ 
+ const applicationMenuHandler = new JSCallback(
+ 	(id, action) => {
+-		const actionString = new CString(action).toString();
++		const actionString = callbackString(action);
+ 
+ 		// Use shared deserialization method
+ 		const { action: actualAction, data } = deserializeMenuAction(actionString);
+@@ -2711,7 +2724,7 @@ const applicationMenuHandler = new JSCallback(
+ 
+ const contextMenuHandler = new JSCallback(
+ 	(_id, action) => {
+-		const actionString = new CString(action).toString();
++		const actionString = callbackString(action);
+ 
+ 		// Use shared deserialization method
+ 		const { action: actualAction, data } = deserializeMenuAction(actionString);

package/src/account/upgrade-dialog.tsx

@@ -23,8 +23,6 @@ import {
   monthsFreeYearly,
   trialDaysOf,
 } from "./billing";
-import { useUpgradePersonalization } from "./upgrade-personalization";
-import { upgradeTickerList } from "./upgrade-tickers";
 
 const CONTENT_WIDTH = 64;
 /** Border plus padding the terminal dialog host draws around the content. */
@@ -117,13 +115,6 @@ export function proStepCopy(offer: UpgradeOffer | null): ProStepCopy {
   };
 }
 
-/** The Pro step's first feature; with tickers it names the account's own holdings. */
-export function proStepRealtimeTitle(tickers: readonly string[] | null): string {
-  return tickers?.length
-    ? tf("Real-time quotes for {tickers}", { tickers: upgradeTickerList(tickers) })
-    : t("Real-time market data");
-}
-
 /** Ranked like the onboarding Pro step: the data first, then what reads it. */
 const PRO_FEATURES: Array<{ label: string; value: string }> = [
   { label: "Real-time data", value: "Free runs 15 min behind on quotes, 12 h on news" },
@@ -132,18 +123,9 @@ const PRO_FEATURES: Array<{ label: string; value: string }> = [
   { label: "Flow and X", value: "Options flow, the X feed and sentiment" },
 ];
 
-/**
- * The feature list, translated. With tickers (the `upgrade_personalized`
- * arm) the real-time row names the account's own tickers; without
- * them it is exactly the generic list.
- */
-export function proFeatureRows(tickers: readonly string[] | null): Array<{ label: string; value: string }> {
-  return PRO_FEATURES.map((feature, index) => ({
-    label: feature.label,
-    value: index === 0 && tickers?.length
-      ? tf("{tickers} quotes, not 15 min behind", { tickers: upgradeTickerList(tickers) })
-      : t(feature.value),
-  }));
+/** The feature list, translated. */
+function proFeatureRows(): Array<{ label: string; value: string }> {
+  return PRO_FEATURES.map((feature) => ({ label: feature.label, value: t(feature.value) }));
 }
 
 /** Pricing and this account's trial and billing state; never rejects, unknowns come back null. */
@@ -175,7 +157,6 @@ function UpgradeDialog({
   useAppLanguage();
   const [interval, setBillingInterval] = useState<CloudBillingInterval>(initialInterval);
   const [offer, setOffer] = useState<UpgradeOffer | null>(null);
-  const personalTickers = useUpgradePersonalization("upgrade-sheet", offer !== null && !offer.paymentFailed);
 
   useEffect(() => {
     let live = true;
@@ -233,7 +214,7 @@ function UpgradeDialog({
               shortcutScope={dialogId}
             />
             <Box height={1} />
-            {proFeatureRows(personalTickers).map((feature) => (
+            {proFeatureRows().map((feature) => (
               <KeyValueRow
                 key={feature.label}
                 label={feature.label}

package/src/api-client/coalesce.ts

@@ -0,0 +1,118 @@
+import { createConcurrencyLimiter } from "../utils/concurrency";
+import { ApiRequestError } from "./errors";
+
+/**
+ * How long a read waits for others: long enough for a board's reads, which
+ * reach the client through caches and routing a few at a time, to meet.
+ */
+const WINDOW_MS = 4;
+
+/**
+ * How long a batch route the service answered 404 is left alone before it is
+ * asked again: an app that updated before its service, or that reached an
+ * instance a deploy had not replaced yet, gets its batches once the service
+ * has them.
+ */
+export const BATCH_ROUTE_REPROBE_MS = 15 * 60_000;
+
+/**
+ * Statuses that refuse a batch as asked (no such route, a request too large or
+ * not understood), which the reads it carried may each get past alone. A rate
+ * limit, an overloaded service or no answer at all is the same for single
+ * requests, and more of them is more of what it refused.
+ */
+const ASKED_ALONE_AFTER = new Set([400, 404, 413, 422]);
+
+/** Whether a batch route's 404 still stands: it is asked again once BATCH_ROUTE_REPROBE_MS has passed. */
+export function createMissingRouteLatch(): { missing(): boolean; refused(error: unknown): void } {
+  let until = 0;
+  return {
+    missing: () => Date.now() < until,
+    refused: (error) => {
+      if (error instanceof ApiRequestError && error.status === 404) until = Date.now() + BATCH_ROUTE_REPROBE_MS;
+    },
+  };
+}
+
+/**
+ * Reads asked in the same moment, sent as batch requests. A read waits a few
+ * milliseconds (WINDOW_MS); the reads of one group gathered by then go out
+ * together through `batch`, at most `max` a request, each answered with its
+ * own item. A lone read goes out on its own, as it always did.
+ *
+ * A batch refused as asked (ASKED_ALONE_AFTER) has its reads asked one at a
+ * time, at most `fallbackConcurrency` at once, and so has every read a batch
+ * left out; a 404 (a service without the route) sends every read that way
+ * until the route is asked again (BATCH_ROUTE_REPROBE_MS). Any other failure
+ * fails every read of the batch with it.
+ */
+export function createReadCoalescer<Key, Result>(options: {
+  max: number;
+  fallbackConcurrency: number;
+  group: (key: Key) => string;
+  batch: (keys: Key[]) => Promise<Array<Result | undefined>>;
+  single: (key: Key) => Promise<Result>;
+}): {
+  read: (key: Key) => Promise<Result>;
+  /** Whether reads asked together now go out in batches: false while the route's 404 stands. */
+  batching: () => boolean;
+} {
+  interface Waiting { key: Key; resolve: (result: Result) => void; reject: (error: unknown) => void }
+  const pending = new Map<string, Waiting[]>();
+  const limit = createConcurrencyLimiter(options.fallbackConcurrency);
+  const route = createMissingRouteLatch();
+  let scheduled = false;
+
+  const one = (waiting: Waiting, limited: boolean) => {
+    (limited ? limit(() => options.single(waiting.key)) : options.single(waiting.key)).then(waiting.resolve, waiting.reject);
+  };
+
+  const send = async (group: Waiting[]) => {
+    if (group.length === 1 || route.missing()) {
+      for (const waiting of group) one(waiting, group.length > 1);
+      return;
+    }
+    let results: Array<Result | undefined>;
+    try {
+      results = await options.batch(group.map((waiting) => waiting.key));
+    } catch (error) {
+      route.refused(error);
+      const alone = error instanceof ApiRequestError && ASKED_ALONE_AFTER.has(error.status ?? 0);
+      for (const waiting of group) {
+        if (alone) one(waiting, true);
+        else waiting.reject(error);
+      }
+      return;
+    }
+    group.forEach((waiting, index) => {
+      const result = results[index];
+      if (result === undefined) one(waiting, true);
+      else waiting.resolve(result);
+    });
+  };
+
+  const flush = () => {
+    scheduled = false;
+    const groups = [...pending.values()];
+    pending.clear();
+    for (const group of groups) {
+      for (let start = 0; start < group.length; start += options.max) void send(group.slice(start, start + options.max));
+    }
+  };
+
+  return {
+    batching: () => !route.missing(),
+    read(key) {
+      return new Promise<Result>((resolve, reject) => {
+        const group = options.group(key);
+        const waiting = pending.get(group);
+        if (waiting) waiting.push({ key, resolve, reject });
+        else pending.set(group, [{ key, resolve, reject }]);
+        if (!scheduled) {
+          scheduled = true;
+          setTimeout(flush, WINDOW_MS);
+        }
+      });
+    },
+  };
+}

package/src/api-client/credit-boards.ts

@@ -3,10 +3,19 @@
  * as daily levels built from DTCC public dissemination.
  */
 
+/**
+ * What a day's level rests on: the day's trades, or the clearing house's
+ * end-of-day settlement price on a day without enough agreeing trades (its
+ * `prints` is then 0). Absent from a server that predates it, which read as
+ * `traded`.
+ */
+export type CreditLevelKind = "traded" | "settlement";
+
 export interface CreditBoardPoint {
   date: string;
   level: number;
   prints: number;
+  kind?: CreditLevelKind;
   /** The contract that was on the run that day, e.g. "2031-12-20". */
   maturity: string;
   /**
@@ -32,6 +41,8 @@ export interface CdxBoardIndex {
   maturity: string | null;
   level: number | null;
   prints: number | null;
+  /** What the latest level rests on, as on each point; null without a level. */
+  kind?: CreditLevelKind | null;
   /** HY and EM: the latest level as a conventional spread in bp, as on each point. */
   spreadBp?: number | null;
   /**
@@ -71,6 +82,8 @@ export interface SovrBoardSovereign {
   level: number;
   prints: number;
   reported: number;
+  /** What the latest level rests on, as on each point. */
+  kind?: CreditLevelKind;
   change1W: number | null;
   change1M: number | null;
   points: CreditBoardPoint[];

package/src/api-client/crypto-etf-flows.ts

@@ -17,6 +17,12 @@ export interface CryptoEtfFlowDay {
   total: number | null;
   /** Funds that reported the day before but show no figure yet. */
   pending: string[];
+  /**
+   * The funds' price move that day: the median of their close-to-close
+   * changes, in percent. Null where too few funds traded; absent when the
+   * server could not read the closes.
+   */
+  priceChangePct?: number | null;
 }
 
 /** `GET /cloud/crypto/etf-flows?asset=btc|eth`: daily net flows of the US spot funds. */

package/src/api-client/crypto-markets.ts

@@ -203,3 +203,43 @@ export interface DefiTvlPayload {
   history: { start: string; total: Array<number | null> } | null;
   warnings: string[];
 }
+
+/** One value per UTC day, oldest first. */
+export interface BitcoinNetworkDailyValue {
+  date: string;
+  value: number;
+}
+
+/**
+ * `GET /cloud/crypto/bitcoin/network`: the bitcoin network's daily hash rate,
+ * the difficulty at each retarget, the next retarget's estimate and hashprice,
+ * derived from the block rewards, the BTC price and the difficulty.
+ */
+export interface BitcoinNetworkPayload {
+  version: 1;
+  generatedAt: string;
+  status: "available" | "stale" | "unavailable";
+  /** Who serves the figures, as a chart cites them: Gloom Cloud. */
+  source: { name: string; url: string };
+  /** When the hash rate and rewards were last read. */
+  historyFetchedAt: string | null;
+  /** Exahashes per second, each UTC day's average; the newest day is the day so far. */
+  hashrate: BitcoinNetworkDailyValue[];
+  /** The difficulty each retarget set, dated by its block. */
+  difficulty: Array<{ date: string; height: number; difficulty: number; changePercent: number | null }>;
+  /** USD per PH/s per day, derived. */
+  hashprice: BitcoinNetworkDailyValue[];
+  /** The estimate of the next retarget, as last read. */
+  retarget: {
+    changePercent: number;
+    estimatedAt: string;
+    nextHeight: number;
+    remainingBlocks: number;
+    progressPercent: number;
+    previousChangePercent: number | null;
+    readAt: string;
+  } | null;
+  /** The estimated change in percent, the last read of each UTC day. */
+  retargetHistory: BitcoinNetworkDailyValue[];
+  warnings: string[];
+}