gloomberb 0.18.4 → 0.19.0

package/src/sync/core-contributors.ts

@@ -1,4 +1,6 @@
 import { saveConfigImmediately, scheduleConfigSave } from "../state/config-save-scheduler";
+import { persistTickerCleanup } from "../state/ticker-cleanup";
+import { hasPendingTickerWrites } from "../data/ticker-writes";
 import { normalizeStoredBaseCurrency } from "../utils/base-currency";
 import { debugLog } from "../utils/debug-log";
 import { fnv1aHex, stableStringify } from "../utils/hash";
@@ -1184,6 +1186,23 @@ function holdingIn(positions: readonly TickerPosition[], links: readonly unknown
   };
 }
 
+/** Without a shared baseline, keep both devices' manual lots, matching identical copies one for one. */
+function mergeUntrackedManualPositions(local: TickerPosition[], pulled: TickerPosition[]): TickerPosition[] {
+  const unmatched = new Map<string, number>();
+  for (const position of local) {
+    const key = JSON.stringify(sanitizePosition(position));
+    unmatched.set(key, (unmatched.get(key) ?? 0) + 1);
+  }
+  const merged = [...local];
+  for (const position of pulled) {
+    const key = JSON.stringify(sanitizePosition(position));
+    const count = unmatched.get(key) ?? 0;
+    if (count > 0) unmatched.set(key, count - 1);
+    else merged.push(position);
+  }
+  return merged;
+}
+
 interface PulledTickersMerge {
   lastSyncedTickers: Map<string, Record<string, unknown>> | null;
   /** This device's live broker portfolios, each with the side holding its latest broker sync. */
@@ -1274,8 +1293,25 @@ function mergePulledTicker(
         holdingIn(baselinePositions, baselineLinks, portfolioId),
       );
     const [sidePositions, sideLinks] = takePulled ? [pulledPositions, pulledLinks] : [localPositions, localLinks];
-    positions.push(...sidePositions.filter((position) => position.portfolio === portfolioId));
-    if (sideLinks.includes(portfolioId)) portfolios.push(portfolioId);
+    if (brokerSide && !merge.localOnly?.portfolioIds.has(portfolioId)) {
+      // A broker's timestamp governs imported holdings, never hand-entered
+      // lots. Those use the same edit comparison as a manual portfolio.
+      const manualIn = (entries: readonly TickerPosition[]) => entries.filter((position) => (
+        position.portfolio === portfolioId && position.broker === "manual"
+      ));
+      const localManual = manualIn(localPositions);
+      const manualEdited = comparable && !sameAsStored(
+        localManual.map(sanitizePosition), manualIn(baselinePositions).map(sanitizePosition),
+      );
+      const pulledManual = manualIn(pulledPositions);
+      const manual = !comparable ? mergeUntrackedManualPositions(localManual, pulledManual)
+        : manualEdited ? localManual : pulledManual;
+      positions.push(...sidePositions.filter((position) => position.portfolio === portfolioId && position.broker !== "manual"), ...manual);
+      if (sideLinks.includes(portfolioId) || manual.length > 0) portfolios.push(portfolioId);
+    } else {
+      positions.push(...sidePositions.filter((position) => position.portfolio === portfolioId));
+      if (sideLinks.includes(portfolioId)) portfolios.push(portfolioId);
+    }
   }
 
   const record: TickerRecord = {
@@ -1297,8 +1333,9 @@ function mergePulledTicker(
 function withoutUnpulledHoldings(ticker: TickerRecord, merge: PulledTickersMerge): TickerRecord | null {
   const sold = (portfolioId: string) => merge.brokerPortfolios.get(portfolioId) === "pulled";
   const { metadata } = ticker;
-  const positions = metadata.positions.filter((position) => !sold(position.portfolio));
-  const portfolios = metadata.portfolios.filter((portfolioId) => !sold(portfolioId));
+  const positions = metadata.positions.filter((position) => position.broker === "manual" || !sold(position.portfolio));
+  const held = new Set(positions.map((position) => position.portfolio));
+  const portfolios = metadata.portfolios.filter((portfolioId) => held.has(portfolioId) || !sold(portfolioId));
   const kept = positions.length === metadata.positions.length && portfolios.length === metadata.portfolios.length
     ? ticker
     : { ...ticker, metadata: { ...metadata, positions, portfolios } };
@@ -1322,12 +1359,57 @@ export const coreConfigSyncContributor: SyncContributor = {
   },
   apply: async (payload, { snapshot, baselinePayload, baselineState, state, getState, isCurrent, dispatch, tickerRepository, memo }) => {
     const pushedAt = snapshot?.contributors[CORE_CONFIG_CONTRIBUTOR_ID]?.updatedAt;
-    const nextConfig = mergeConfigPayload(state.config, payload, baselineState.config, baselinePayload, {
+    const merge = (config: AppConfig) => mergeConfigPayload(config, payload, baselineState.config, baselinePayload, {
       memo: memo?.get(),
       pushedAt,
-    }, localOnlyScope(state.config));
+    }, localOnlyScope(config));
+    let nextConfig = merge(state.config);
     if (!nextConfig) return;
-    const configChanged = !valuesEqual(nextConfig, state.config);
+    const removed = removedBrokerHoldings(state.config, nextConfig);
+    if (removed) {
+      // Keep the profile until row and config writes succeed, so a failed
+      // cleanup remains visible to the next attempt.
+      const cleanTickers = () => persistTickerCleanup({
+        tickerRepository,
+        getTickers: () => getState().tickers,
+        transform: (ticker) => withoutRemovedBrokerHoldings(ticker, removed),
+        publish: (symbol, ticker) => {
+          const tickers = new Map(getState().tickers);
+          if (ticker) tickers.set(symbol, ticker);
+          else tickers.delete(symbol);
+          dispatch({ type: "SET_TICKERS", tickers });
+        },
+        isCurrent,
+      });
+      let savedRemoval = false;
+      for (;;) {
+        const cleaned = await cleanTickers().catch(async (error: unknown) => {
+          // Restore the profile if a late row fails after config was saved,
+          // so retry can also recover after restarting the app.
+          if (savedRemoval) await saveConfigImmediately(getState().config);
+          throw error;
+        });
+        if (!cleaned || !isCurrent()) return;
+        if (hasPendingTickerWrites(tickerRepository) || getState().tickers !== cleaned) continue;
+        const source = getState().config;
+        const merged = merge(source);
+        if (!merged) return;
+        // Preserve unrelated edits while retaining the removal already applied
+        // to rows, including pulls from builds that merged whole profile lists.
+        nextConfig = {
+          ...merged,
+          brokerInstances: merged.brokerInstances.filter((instance) => !removed.instanceIds.has(instance.id)),
+          portfolios: merged.portfolios.filter((portfolio) => !removed.portfolioIds.has(portfolio.id)),
+        };
+        await saveConfigImmediately(nextConfig);
+        savedRemoval = true;
+        if (!isCurrent()) return;
+        if (getState().config !== source || getState().tickers !== cleaned
+          || hasPendingTickerWrites(tickerRepository)) continue;
+        break;
+      }
+    }
+    const configChanged = !valuesEqual(nextConfig, getState().config);
     if (configChanged) {
       // Adopting another device's workspace rearranges the screen under the
       // user, so it is worth a line in the log when a report says "my panes
@@ -1339,32 +1421,9 @@ export const coreConfigSyncContributor: SyncContributor = {
         });
       }
       dispatch({ type: "SET_CONFIG", config: nextConfig });
-      scheduleConfigSave(nextConfig);
+      if (!removed) scheduleConfigSave(nextConfig);
     }
     if (memo && isRecord(payload)) rememberCloudLayout(payload, pushedAt, getState().config, memo, nextConfig.layouts !== state.config.layouts);
-    if (!configChanged) return;
-
-    // A profile removed on another device takes its positions with it here
-    // too; kept, this device would push them back and recreate the tickers
-    // that removal deleted.
-    const removed = removedBrokerHoldings(state.config, nextConfig);
-    if (!removed) return;
-    const nextTickers = new Map(getState().tickers);
-    let changed = false;
-    for (const ticker of getState().tickers.values()) {
-      if (!isCurrent()) return;
-      const next = withoutRemovedBrokerHoldings(ticker, removed);
-      if (next === ticker) continue;
-      changed = true;
-      if (next) {
-        await tickerRepository.saveTicker(next);
-        nextTickers.set(next.metadata.ticker, next);
-      } else {
-        await tickerRepository.deleteTicker(ticker.metadata.ticker);
-        nextTickers.delete(ticker.metadata.ticker);
-      }
-    }
-    if (changed && isCurrent()) dispatch({ type: "SET_TICKERS", tickers: nextTickers });
   },
 };
 

package/src/sync/react.ts

@@ -39,6 +39,8 @@ export function useCloudSyncRuntime({
       dispatch,
       tickerRepository,
       baselineStore,
+      getSessionIdentity: () => apiClient.getVerifiedSessionIdentity(),
+      getAccountId: () => apiClient.getVerifiedSessionIdentity() ? apiClient.getCurrentUser()?.id ?? null : null,
       getContributors: () => pluginRegistry.getEnabledSyncContributors(),
       getTransport: () => pluginRegistry.getActiveSyncTransport(),
       isLocalMarketData: (providerId) => {
@@ -69,7 +71,8 @@ export function useCloudSyncRuntime({
     // Email verification makes the Cloud transport available. Force the first
     // sync so a workspace completed before verification is uploaded promptly.
     void cloudSyncController.requestSync({ reason: "session-verified", force: true });
-  }), [initialized]);
+  }, (accountId) => cloudSyncController.resetAccount(accountId),
+  () => cloudSyncController.retireSession()), [initialized]);
 
   useEffect(() => {
     if (!initialized) return;

package/src/sync/types.ts

@@ -121,6 +121,9 @@ export interface SyncSettings {
 
 /** Durable record of the payloads this device last pushed to the cloud. */
 export interface SyncBaselineStore {
+  /** Account that owns this merge history; absent on stores written before account tracking. */
+  loadAccountId?(): string | null;
+  saveAccountId?(accountId: string): void;
   load(): Record<string, unknown> | null;
   save(payloads: Record<string, unknown>): void;
   /** Contributor memos by contributor id; see `SyncContributorMemo`. */

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

@@ -0,0 +1,38 @@
+import type { StallEvent } from "../utils/main-thread-stall";
+
+/**
+ * Only the freezes a user sat through. The system slows the timers of a
+ * window behind others or out of view, sometimes to one a second, and the
+ * stall monitor cannot tell that from a freeze: a timer back a second late
+ * reads the same either way. A window that has been in front, with focus,
+ * since before the stall began ran at full speed, so its late timers are
+ * freezes. Anything else is dropped, including a real freeze the user
+ * clicked into the window during: missing one beats reporting a false one.
+ */
+export function forwardAttendedStalls(
+  forward: (event: StallEvent) => void,
+  target: Window = window,
+  now: () => number = () => performance.now(),
+): { sink: (event: StallEvent) => void; dispose: () => void } {
+  const doc = target.document;
+  const attended = () => doc.visibilityState === "visible" && doc.hasFocus();
+  // Since when the window has been attended; never while it is not.
+  let attendedSince = attended() ? now() : Number.POSITIVE_INFINITY;
+  const update = () => {
+    if (!attended()) attendedSince = Number.POSITIVE_INFINITY;
+    else if (attendedSince === Number.POSITIVE_INFINITY) attendedSince = now();
+  };
+  target.addEventListener("focus", update);
+  target.addEventListener("blur", update);
+  doc.addEventListener("visibilitychange", update);
+  return {
+    sink: (event) => {
+      if (attended() && attendedSince <= now() - event.blockedMs) forward(event);
+    },
+    dispose: () => {
+      target.removeEventListener("focus", update);
+      target.removeEventListener("blur", update);
+      doc.removeEventListener("visibilitychange", update);
+    },
+  };
+}

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

@@ -0,0 +1,75 @@
+import { appendFileSync, existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "fs";
+import { join } from "path";
+import type { StallReportState, StallReporterHost } from "./stall-reports";
+
+/** Next to config.json: one line per stall, newest last. */
+const STALL_LOG_FILE = "stall-log.txt";
+/** Next to config.json: when each kind of stall was last reported, and the counts since. */
+const STATE_FILE = "stall-reports.json";
+/** Past this the log keeps its newer half. */
+const LOG_MAX_BYTES = 256 * 1024;
+
+function readCounts(value: unknown): StallReportState["pending"] {
+  const pending: StallReportState["pending"] = {};
+  if (!value || typeof value !== "object") return pending;
+  for (const [key, entry] of Object.entries(value as Record<string, unknown>)) {
+    const { count, longestMs } = (entry ?? {}) as Record<string, unknown>;
+    if (typeof count === "number" && Number.isFinite(count) && typeof longestMs === "number" && Number.isFinite(longestMs)) {
+      pending[key] = { count, longestMs };
+    }
+  }
+  return pending;
+}
+
+/** The saved state, keeping only entries of the right shape. */
+function parseStallReportState(text: string): StallReportState {
+  const parsed: unknown = JSON.parse(text);
+  const record = parsed && typeof parsed === "object" ? parsed as Record<string, unknown> : {};
+  const sent: Record<string, number> = {};
+  if (record.sent && typeof record.sent === "object") {
+    for (const [key, at] of Object.entries(record.sent as Record<string, unknown>)) {
+      if (typeof at === "number" && Number.isFinite(at)) sent[key] = at;
+    }
+  }
+  return { sent, pending: readCounts(record.pending) };
+}
+
+function trimLog(path: string): void {
+  if (statSync(path).size <= LOG_MAX_BYTES) return;
+  const text = readFileSync(path, "utf-8");
+  const keep = text.slice(text.length - LOG_MAX_BYTES / 2);
+  writeFileSync(path, keep.slice(keep.indexOf("\n") + 1), "utf-8");
+}
+
+/** The stall reporter for a Bun process (the terminal app, the desktop app's main process). */
+export function createNodeStallReporterHost(options: {
+  /** The profile's data folder, or null before the config is loaded. */
+  getDataDir(): string | null;
+}): StallReporterHost {
+  const pathFor = (file: string) => {
+    const dir = options.getDataDir();
+    return dir ? join(dir, file) : null;
+  };
+  return {
+    platform: process.platform,
+    arch: process.arch,
+    appendLog: (line) => {
+      const path = pathFor(STALL_LOG_FILE);
+      if (!path) return;
+      mkdirSync(join(path, ".."), { recursive: true });
+      appendFileSync(path, `${line}\n`, "utf-8");
+      trimLog(path);
+    },
+    load: () => {
+      const path = pathFor(STATE_FILE);
+      if (!path || !existsSync(path)) return { sent: {}, pending: {} };
+      return parseStallReportState(readFileSync(path, "utf-8"));
+    },
+    save: (state) => {
+      const path = pathFor(STATE_FILE);
+      if (!path) return;
+      mkdirSync(join(path, ".."), { recursive: true });
+      writeFileSync(path, JSON.stringify(state), "utf-8");
+    },
+  };
+}

package/src/telemetry/stall-reports.ts

@@ -0,0 +1,214 @@
+import { logFailure } from "../utils/log-failure";
+import type { StallEvent } from "../utils/main-thread-stall";
+import { VERSION } from "../version";
+import { reportCrash } from "./crash-reports";
+
+/**
+ * Freezes, made visible outside the app's own Debug Log.
+ *
+ * The stall monitor (utils/main-thread-stall.ts) notices when a process could
+ * not answer the user for a while and names the last measured section, and
+ * hands the stall to its sink. The terminal app and the desktop app's Bun
+ * process record their own stalls here; the desktop window sends the stalls
+ * it had in front of the user (stall-reports-dom.ts) to the Bun process,
+ * which records them too. Where a host is installed, each
+ * stall:
+ *
+ * - goes to a plain-text stall log in the profile folder, one line each, so a
+ *   user or support can read what froze and when;
+ * - from a second up, counts toward a report sent through the crash reporter
+ *   (and so behind the same off switch), the way update failures are: the
+ *   duration bucket, the section's fixed name, the process, the longest
+ *   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.
+ *
+ * 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.
+ */
+
+/** Which process stalled. */
+export type StallProcess = "window" | "app" | "terminal";
+
+/** What error tracking gets: fixed values only. */
+export interface StallReport {
+  process: StallProcess;
+  bucket: StallBucket;
+  section: string;
+  appVersion: string;
+  platform: "macos" | "windows" | "linux" | "other";
+  arch: "arm64" | "x64" | "other";
+  /** Stalls of this kind since the last report, this one included. */
+  count: number;
+  /** The longest of them, rounded to 100 ms. */
+  longestMs: number;
+}
+
+type StallBucket = "1-2s" | "2-5s" | "5-15s" | "15s+";
+
+/** What the host keeps on disk between launches. */
+export interface StallReportState {
+  /** When each kind was last reported, in ms. */
+  sent: Record<string, number>;
+  /** Stalls counted since each kind was last reported. */
+  pending: Record<string, { count: number; longestMs: number }>;
+}
+
+export interface StallReporterHost {
+  /** The running version; defaults to this build's. */
+  appVersion?: string;
+  platform: string;
+  arch: string;
+  /** Appends one line to the stall log. */
+  appendLog(line: string): void;
+  load(): StallReportState;
+  save(state: StallReportState): void;
+  now?(): number;
+  /** Defaults to the crash reporter. */
+  send?(report: StallReport): void;
+}
+
+const DAY_MS = 24 * 60 * 60 * 1000;
+/** Shorter freezes go to the log only. */
+const STALL_REPORT_MIN_MS = 1_000;
+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;
+
+let host: StallReporterHost | null = null;
+
+/** The fixed part of a section name: lower-case dotted words, cut where anything else starts. */
+function stallSectionName(name: string | undefined): string {
+  if (!name) return "unmeasured";
+  const match = SECTION_PATTERN.exec(name);
+  const section = match?.[0].replace(/\.$/, "");
+  return section && section.length <= 80 ? section : "unmeasured";
+}
+
+function stallBucket(blockedMs: number): StallBucket {
+  if (blockedMs < 2_000) return "1-2s";
+  if (blockedMs < 5_000) return "2-5s";
+  if (blockedMs < 15_000) return "5-15s";
+  return "15s+";
+}
+
+/** 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>;
+  if (typeof blockedMs !== "number" || !Number.isFinite(blockedMs) || blockedMs <= 0) return null;
+  return {
+    blockedMs,
+    ...(typeof lastMeasured === "string" && lastMeasured.length <= 200 ? { lastMeasured } : {}),
+    ...(typeof lastMeasuredEndedMsAgo === "number" && Number.isFinite(lastMeasuredEndedMsAgo) ? { lastMeasuredEndedMsAgo } : {}),
+  };
+}
+
+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 {
+  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}`;
+}
+
+function reportPlatform(platform: string): StallReport["platform"] {
+  if (platform === "darwin") return "macos";
+  if (platform === "win32") return "windows";
+  if (platform === "linux") return "linux";
+  return "other";
+}
+
+function reportArch(arch: string): StallReport["arch"] {
+  return arch === "arm64" || arch === "x64" ? arch : "other";
+}
+
+function sendThroughCrashReporter(report: StallReport): void {
+  const details = [
+    `process=${report.process}`,
+    `count=${report.count}`,
+    `longest=${report.longestMs}ms`,
+    `platform=${report.platform}-${report.arch}`,
+  ].join(" ");
+  // 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(
+    { name: "MainThreadStall", message: `${report.bucket} after ${report.section}` },
+    { kind: "plugin", plugin: "stall-monitor", pane: details },
+  );
+}
+
+function loadState(current: StallReporterHost): StallReportState {
+  try {
+    const state = current.load();
+    return { sent: { ...state.sent }, pending: { ...state.pending } };
+  } catch (error) {
+    logFailure("telemetry-stalls", "Could not read stall report state")(error);
+    return { sent: {}, pending: {} };
+  }
+}
+
+function prune(state: StallReportState, now: number): void {
+  for (const [key, at] of Object.entries(state.sent)) {
+    if (!(now - at < DAY_MS) || at > now) delete state.sent[key];
+  }
+  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];
+}
+
+/** Records one stall of `process`. Does nothing where no host is installed; never throws. */
+export function recordStall(process: StallProcess, event: StallEvent): void {
+  const current = host;
+  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 appVersion = (current.appVersion ?? VERSION).trim().replace(/^v/, "");
+    const section = stallSectionName(event.lastMeasured);
+    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 pending = state.pending[key] ?? { count: 0, longestMs: 0 };
+    pending.count += 1;
+    pending.longestMs = Math.max(pending.longestMs, Math.round(event.blockedMs / 100) * 100);
+    if (state.sent[key] !== undefined) {
+      state.pending[key] = pending;
+    } else {
+      delete state.pending[key];
+      state.sent[key] = now;
+      (current.send ?? sendThroughCrashReporter)({
+        process,
+        bucket,
+        section,
+        appVersion: version,
+        platform: reportPlatform(current.platform),
+        arch: reportArch(current.arch),
+        count: pending.count,
+        longestMs: pending.longestMs,
+      });
+    }
+    current.save(state);
+  } catch (error) {
+    logFailure("telemetry-stalls", "Could not record a stall")(error);
+  }
+}
+
+export function installStallReporter(next: StallReporterHost): () => void {
+  host = next;
+  return () => {
+    if (host === next) host = null;
+  };
+}
+
+/** Test seam. */
+export function resetStallReporterForTests(): void {
+  host = null;
+}

package/src/telemetry/usage-counts.ts

@@ -97,7 +97,6 @@ let officialIds: ReadonlySet<string> | null = null;
 let officialLookup: Promise<void> | null = null;
 let automationDepth = 0;
 const builtinPlugins = new WeakSet<object>();
-const openListeners = new Set<() => void>();
 
 /** Reads the config switch and the environment. Absent means on. */
 export function usageCountsEnabled(
@@ -197,27 +196,10 @@ export function automationActive(): boolean {
   return automationDepth > 0;
 }
 
-/**
- * Calls `listener` each time the user opens a function, with nothing about
- * which one. The web terminal's first-screen measure uses it; automation never
- * reaches it.
- */
-export function subscribeFunctionOpens(listener: () => void): () => void {
-  openListeners.add(listener);
-  return () => {
-    openListeners.delete(listener);
-  };
-}
-
 /** Counts one open of a function by the user. Never throws. */
 export function recordFunctionOpen(fn: UsageFunction): void {
   try {
     if (automationDepth > 0) return;
-    for (const listener of openListeners) {
-      try { listener(); } catch (error) {
-        logFailure("telemetry-usage-counts", "Could not notify function-open listener")(error);
-      }
-    }
     if (host && !host.isEnabled()) return;
     count(fn, "opened");
     scheduleFlush();

package/src/test-support/preload.ts

@@ -0,0 +1,14 @@
+import { beforeEach } from "bun:test";
+import { resetCrashReporterForTests } from "../telemetry/crash-reports";
+
+/**
+ * `bun test` runs every file in one process, so module state outlives the file
+ * that set it. A crash report queued while no reporter is installed, such as a
+ * plugin that fails to register in an app runtime test, would wait in the
+ * queue and go out with the next reporter another file installs, and its key
+ * would keep a later identical report from being queued at all. Every test
+ * starts with no reporter, an empty queue and nothing seen.
+ */
+beforeEach(() => {
+  resetCrashReporterForTests();
+});

package/src/theme/colors.ts

@@ -291,6 +291,14 @@ export function priceColor(value: number, palette: ThemeColors = colors): string
   return palette.neutral;
 }
 
+/**
+ * `priceColor` for a figure as it is printed, to `digits` decimals: a move that
+ * rounds to zero (0.00%, never -0.00%) is neutral, not red or green.
+ */
+export function shownPriceColor(value: number, digits: number, palette: ThemeColors = colors): string {
+  return priceColor(Number(value.toFixed(digits)), palette);
+}
+
 const TONE_TINT = 0.18;
 
 /**

package/src/theme/themes.ts

@@ -745,6 +745,16 @@ const THEME_TRAITS: Readonly<Record<string, readonly ThemeTrait[]>> = {
   "high-contrast": ["high-contrast", "colorblind-safe"],
 };
 
+/**
+ * Whether a theme's gains and losses are told apart by something other than
+ * the red and green everyone reads: a color-blind safe theme's blue and
+ * vermillion, which a chart keys (`▲▼` beside a candle series) so a reader
+ * knows which is which.
+ */
+export function themeKeysDirection(id: string): boolean {
+  return (THEME_TRAITS[id] ?? []).includes("colorblind-safe");
+}
+
 export interface ThemeSummary {
   id: string;
   name: string;