gloomberb 0.4.0 → 0.5.0

package/src/types/config.ts

@@ -179,7 +179,7 @@ export const DEFAULT_LAYOUT: LayoutConfig = {
         hideTabs: false,
         lockedTabId: "overview",
         chartRangePreset: "5Y",
-        chartResolution: "1wk",
+        chartResolution: "auto",
       },
       binding: { kind: "follow", sourceInstanceId: "portfolio-list:main" },
     },
@@ -317,6 +317,35 @@ export function isFixedTickerPane(instance: PaneInstanceConfig): boolean {
   return isTickerPaneInstance(instance) && instance.binding?.kind === "fixed";
 }
 
+export function findPrimaryPaneInstance(layout: LayoutConfig, paneId: string): PaneInstanceConfig | undefined {
+  const instances = layout.instances.filter((instance) => instance.paneId === paneId);
+  if (instances.length === 0) return undefined;
+  if (!isTickerPaneId(paneId)) return instances[0];
+  return instances.find((instance) => instance.instanceId === `${paneId}:main` && instance.binding?.kind !== "fixed")
+    ?? instances.find((instance) => instance.binding?.kind !== "fixed");
+}
+
+export function resolvePaneInstance(layout: LayoutConfig, paneIdOrInstanceId: string): PaneInstanceConfig | undefined {
+  return findPaneInstance(layout, paneIdOrInstanceId) ?? findPrimaryPaneInstance(layout, paneIdOrInstanceId);
+}
+
+export function resolveFollowBindingInstance(
+  layout: LayoutConfig,
+  paneIdOrInstanceId: string | null | undefined,
+  matcher: (instance: PaneInstanceConfig) => boolean,
+  seen = new Set<string>(),
+): PaneInstanceConfig | undefined {
+  if (!paneIdOrInstanceId) return undefined;
+  const instance = resolvePaneInstance(layout, paneIdOrInstanceId);
+  if (!instance || seen.has(instance.instanceId)) return undefined;
+  seen.add(instance.instanceId);
+  if (matcher(instance)) return instance;
+  if (instance.binding?.kind === "follow") {
+    return resolveFollowBindingInstance(layout, instance.binding.sourceInstanceId, matcher, seen);
+  }
+  return undefined;
+}
+
 export function createPaneInstance(
   paneId: string,
   options: Partial<PaneInstanceConfig> = {},

package/src/types/data-provider.ts

@@ -26,6 +26,18 @@ export interface SecFilingItem {
   primaryDocumentUrl?: string;
 }
 
+export interface EarningsEvent {
+  symbol: string;
+  name: string;
+  earningsDate: Date;
+  epsEstimate: number | null;
+  epsActual: number | null;
+  revenueEstimate: number | null;
+  revenueActual: number | null;
+  surprise: number | null;
+  timing: "BMO" | "AMC" | "TNS" | "";
+}
+
 export interface MarketDataRequestContext {
   brokerId?: string;
   brokerInstanceId?: string;
@@ -68,6 +80,7 @@ export interface DataProvider {
   search(query: string, context?: SearchRequestContext): Promise<InstrumentSearchResult[]>;
   getNews(ticker: string, count?: number, exchange?: string, context?: MarketDataRequestContext): Promise<NewsItem[]>;
   getSecFilings?(ticker: string, count?: number, exchange?: string, context?: MarketDataRequestContext): Promise<SecFilingItem[]>;
+  getEarningsCalendar?(symbols: string[], context?: MarketDataRequestContext): Promise<EarningsEvent[]>;
   getSecFilingContent?(filing: SecFilingItem): Promise<string | null>;
   /** Fetch article summary/description by URL (lazy-loaded on selection) */
   getArticleSummary(url: string): Promise<string | null>;

package/src/types/plugin.ts

@@ -169,6 +169,19 @@ export interface WizardStep {
   body?: string[];
 }
 
+export interface CommandShortcutArgContext {
+  activeTicker: string | null;
+}
+
+export interface CommandShortcutArgDef {
+  placeholder?: string;
+  kind?: "text" | "ticker" | "ticker-list";
+  parse?: (
+    arg: string,
+    context: CommandShortcutArgContext,
+  ) => Record<string, string>;
+}
+
 export interface CliHelpColumn {
   header: string;
   align?: "left" | "right" | "center";
@@ -243,6 +256,7 @@ export interface CommandDef {
   label: string;
   keywords: string[];
   shortcut?: string;
+  shortcutArg?: CommandShortcutArgDef;
   execute: (values?: Record<string, string>) => void | Promise<void>;
   category: "navigation" | "data" | "portfolio" | "config";
   description?: string;
@@ -355,6 +369,25 @@ export interface PluginPaneSettingsState {
   delete(paneId: string, key: string): Promise<void>;
 }
 
+export type AppNotificationType = "info" | "success" | "error";
+export type AppDesktopNotificationMode = "never" | "when-inactive" | "always";
+
+export interface AppNotificationRequest {
+  title?: string;
+  body: string;
+  subtitle?: string;
+  duration?: number;
+  type?: AppNotificationType;
+  toast?: boolean;
+  desktop?: AppDesktopNotificationMode;
+  persistent?: boolean;
+  sound?: string;
+  action?: {
+    label: string;
+    onClick: () => void;
+  };
+}
+
 export interface GloomPluginContext {
   registerPane(pane: PaneDef): void;
   registerPaneTemplate(template: PaneTemplateDef): void;
@@ -392,6 +425,7 @@ export interface GloomPluginContext {
   hidePane(paneId: string): void;
   focusPane(paneId: string): void;
   pinTicker(symbol: string, options?: { floating?: boolean; paneType?: string }): void;
+  navigateTicker(symbol: string): void;
   openPaneSettings(paneId?: string): void;
 
   on<K extends keyof PluginEvents>(event: K, handler: (payload: PluginEvents[K]) => void): () => void;
@@ -399,7 +433,7 @@ export interface GloomPluginContext {
 
   showWidget(widgetId: string): void;
   hideWidget(widgetId: string): void;
-  showToast(message: string, options?: { duration?: number; type?: "info" | "success" | "error" }): void;
+  notify(notification: AppNotificationRequest): void;
 }
 
 export interface GloomPlugin {

package/src/updater.test.ts

@@ -272,6 +272,8 @@ describe("performUpdate", () => {
       });
 
       expect(readFileSync(execPath)).toEqual(nextBinary);
+      expect(progress[0]).toEqual({ phase: "downloading", percent: 0 });
+      expect(progress).toContainEqual({ phase: "downloading", percent: 100 });
       expect(progress.at(-1)).toEqual({ phase: "done" });
     } finally {
       Object.defineProperty(process, "execPath", { value: originalExecPath, configurable: true });

package/src/utils/api-client.ts

@@ -647,6 +647,18 @@ class GloomApiClient {
     };
   }
 
+  dispose(): void {
+    cloudApiLog.info("dispose api client", {
+      quoteTargets: this.quoteTargets.size,
+      channelTargets: this.channelListeners.size,
+    });
+    this.channelListeners.clear();
+    this.quoteListeners.clear();
+    this.quoteTargets.clear();
+    this.reconnectDelayMs = 1000;
+    this.teardownSocket();
+  }
+
   async searchInstruments(query: string, limit = 10): Promise<InstrumentSearchResult[]> {
     const params = new URLSearchParams({
       q: query,

package/src/utils/format.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import { formatTimeAgo } from "./format";
+import { displayWidth, formatTimeAgo, padTo } from "./format";
 
 describe("formatTimeAgo", () => {
   test("handles UTC ISO timestamps with explicit offsets", () => {
@@ -12,3 +12,13 @@ describe("formatTimeAgo", () => {
     expect(formatTimeAgo(fiveMinutesAgo)).toBe("5m ago");
   });
 });
+
+describe("padTo", () => {
+  test("pads and truncates by display width instead of UTF-16 length", () => {
+    expect(displayWidth("🇺🇸")).toBe(2);
+    expect(padTo("🇺🇸", 2)).toBe("🇺🇸");
+    expect(padTo("🇺🇸", 3)).toBe("🇺🇸 ");
+    expect(padTo("🇺🇸", 1)).toBe(" ");
+    expect(padTo("🇺🇸 CPI", 6)).toBe("🇺🇸 CPI");
+  });
+});

package/src/utils/format.ts

@@ -116,17 +116,95 @@ export function formatWithDivisor(value: number | undefined, divisor: number): s
   return scaled.toFixed(decimals);
 }
 
-/** Pad/truncate a string to a fixed width */
+const COMBINING_MARK_RE = /\p{Mark}/u;
+const EMOJI_PRESENTATION_RE = /\p{Emoji_Presentation}/u;
+const EXTENDED_PICTOGRAPHIC_RE = /\p{Extended_Pictographic}/u;
+const REGIONAL_INDICATOR_RE = /\p{Regional_Indicator}/u;
+
+function segmentGraphemes(value: string): string[] {
+  const Segmenter = (Intl as any).Segmenter;
+  if (typeof Segmenter === "function") {
+    return Array.from(
+      new Segmenter(undefined, { granularity: "grapheme" }).segment(value),
+      (entry: any) => entry.segment as string,
+    );
+  }
+  return Array.from(value);
+}
+
+function isFullwidthCodePoint(codePoint: number): boolean {
+  return codePoint >= 0x1100 && (
+    codePoint <= 0x115f ||
+    codePoint === 0x2329 ||
+    codePoint === 0x232a ||
+    (codePoint >= 0x2e80 && codePoint <= 0xa4cf && codePoint !== 0x303f) ||
+    (codePoint >= 0xac00 && codePoint <= 0xd7a3) ||
+    (codePoint >= 0xf900 && codePoint <= 0xfaff) ||
+    (codePoint >= 0xfe10 && codePoint <= 0xfe19) ||
+    (codePoint >= 0xfe30 && codePoint <= 0xfe6f) ||
+    (codePoint >= 0xff00 && codePoint <= 0xff60) ||
+    (codePoint >= 0xffe0 && codePoint <= 0xffe6) ||
+    (codePoint >= 0x1f300 && codePoint <= 0x1faff) ||
+    (codePoint >= 0x20000 && codePoint <= 0x3fffd)
+  );
+}
+
+function graphemeWidth(segment: string): number {
+  if (
+    REGIONAL_INDICATOR_RE.test(segment) ||
+    EMOJI_PRESENTATION_RE.test(segment) ||
+    EXTENDED_PICTOGRAPHIC_RE.test(segment)
+  ) {
+    return 2;
+  }
+
+  let width = 0;
+  for (const char of Array.from(segment)) {
+    const codePoint = char.codePointAt(0) ?? 0;
+    if (
+      codePoint === 0 ||
+      codePoint < 32 ||
+      (codePoint >= 0x7f && codePoint < 0xa0) ||
+      codePoint === 0x200d ||
+      (codePoint >= 0xfe00 && codePoint <= 0xfe0f) ||
+      COMBINING_MARK_RE.test(char)
+    ) {
+      continue;
+    }
+    width += isFullwidthCodePoint(codePoint) ? 2 : 1;
+  }
+  return width;
+}
+
+export function displayWidth(value: string): number {
+  return segmentGraphemes(value).reduce((total, segment) => total + graphemeWidth(segment), 0);
+}
+
+function truncateToWidth(value: string, width: number): string {
+  if (width <= 0) return "";
+  let output = "";
+  let used = 0;
+  for (const segment of segmentGraphemes(value)) {
+    const nextWidth = graphemeWidth(segment);
+    if (used + nextWidth > width) break;
+    output += segment;
+    used += nextWidth;
+  }
+  return output;
+}
+
+/** Pad/truncate a string to a fixed display width */
 export function padTo(str: string, width: number, align: "left" | "right" | "center" = "left"): string {
-  if (str.length > width) return str.slice(0, width);
-  if (align === "right") return str.padStart(width);
+  const clipped = displayWidth(str) > width ? truncateToWidth(str, width) : str;
+  const clippedWidth = displayWidth(clipped);
+  const padding = Math.max(0, width - clippedWidth);
+  if (align === "right") return " ".repeat(padding) + clipped;
   if (align === "center") {
-    const totalPadding = width - str.length;
-    const leftPadding = Math.floor(totalPadding / 2);
-    const rightPadding = totalPadding - leftPadding;
-    return " ".repeat(leftPadding) + str + " ".repeat(rightPadding);
+    const leftPadding = Math.floor(padding / 2);
+    const rightPadding = padding - leftPadding;
+    return " ".repeat(leftPadding) + clipped + " ".repeat(rightPadding);
   }
-  return str.padEnd(width);
+  return clipped + " ".repeat(padding);
 }
 
 /** Convert a value from one currency to base currency using cached exchange rates */

package/src/utils/inline-content-tokenizer.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, test } from "bun:test";
+import { tokenizeInlineContent } from "./inline-content-tokenizer";
+
+describe("tokenizeInlineContent", () => {
+  test("returns mixed text, link, and ticker tokens in one pass", () => {
+    expect(tokenizeInlineContent("Read https://example.com then watch $NVDA")).toEqual([
+      { kind: "text", value: "Read " },
+      { kind: "link", value: "https://example.com", url: "https://example.com" },
+      { kind: "text", value: " then watch " },
+      { kind: "ticker", value: "$NVDA", symbol: "NVDA" },
+    ]);
+  });
+
+  test("does not split ticker-like text out of links", () => {
+    expect(tokenizeInlineContent("Read https://example.com/$TSLA before $NVDA")).toEqual([
+      { kind: "text", value: "Read " },
+      { kind: "link", value: "https://example.com/$TSLA", url: "https://example.com/$TSLA" },
+      { kind: "text", value: " before " },
+      { kind: "ticker", value: "$NVDA", symbol: "NVDA" },
+    ]);
+  });
+});

package/src/utils/inline-content-tokenizer.ts

@@ -0,0 +1,76 @@
+import { tokenizeInlineLinks } from "./link-tokenizer";
+
+export interface InlineContentTextToken {
+  kind: "text";
+  value: string;
+}
+
+export interface InlineContentLinkToken {
+  kind: "link";
+  value: string;
+  url: string;
+}
+
+export interface InlineContentTickerToken {
+  kind: "ticker";
+  value: string;
+  symbol: string;
+}
+
+export type InlineContentToken =
+  | InlineContentTextToken
+  | InlineContentLinkToken
+  | InlineContentTickerToken;
+
+const TICKER_TOKEN_RE = /\$[A-Z][A-Z0-9.-]{0,9}/g;
+const SYMBOL_CHAR_RE = /[A-Za-z0-9.-]/;
+
+function trimTrailingTickerPunctuation(value: string): string {
+  let trimmed = value;
+  while (trimmed.length > 2 && /[.-]$/.test(trimmed)) {
+    trimmed = trimmed.slice(0, -1);
+  }
+  return trimmed;
+}
+
+function isValidTickerBoundary(text: string, start: number, end: number): boolean {
+  const prev = start > 0 ? text[start - 1] : "";
+  const next = end < text.length ? text[end] : "";
+  return !SYMBOL_CHAR_RE.test(prev) && !SYMBOL_CHAR_RE.test(next);
+}
+
+export function tokenizeInlineContent(text: string): InlineContentToken[] {
+  const tokens: InlineContentToken[] = [];
+
+  for (const segment of tokenizeInlineLinks(text)) {
+    if (segment.kind === "link") {
+      tokens.push(segment);
+      continue;
+    }
+
+    let cursor = 0;
+    let match: RegExpExecArray | null;
+
+    TICKER_TOKEN_RE.lastIndex = 0;
+    while ((match = TICKER_TOKEN_RE.exec(segment.value)) !== null) {
+      const rawValue = match[0];
+      const start = match.index;
+      const rawEnd = start + rawValue.length;
+      const value = trimTrailingTickerPunctuation(rawValue);
+      const end = start + value.length;
+      if (!isValidTickerBoundary(segment.value, start, rawEnd)) continue;
+
+      if (start > cursor) {
+        tokens.push({ kind: "text", value: segment.value.slice(cursor, start) });
+      }
+      tokens.push({ kind: "ticker", value, symbol: value.slice(1) });
+      cursor = end;
+    }
+
+    if (cursor < segment.value.length) {
+      tokens.push({ kind: "text", value: segment.value.slice(cursor) });
+    }
+  }
+
+  return tokens;
+}

package/src/utils/link-tokenizer.test.ts

@@ -0,0 +1,27 @@
+import { describe, expect, test } from "bun:test";
+import { tokenizeInlineLinks } from "./link-tokenizer";
+
+describe("tokenizeInlineLinks", () => {
+  test("extracts http links and preserves surrounding text", () => {
+    expect(tokenizeInlineLinks("Read https://example.com/story now")).toEqual([
+      { kind: "text", value: "Read " },
+      { kind: "link", value: "https://example.com/story", url: "https://example.com/story" },
+      { kind: "text", value: " now" },
+    ]);
+  });
+
+  test("drops trailing punctuation from the link token", () => {
+    expect(tokenizeInlineLinks("See https://example.com/story.)")).toEqual([
+      { kind: "text", value: "See " },
+      { kind: "link", value: "https://example.com/story", url: "https://example.com/story" },
+      { kind: "text", value: ".)" },
+    ]);
+  });
+
+  test("normalizes www links for opening", () => {
+    expect(tokenizeInlineLinks("Visit www.example.com/test")).toEqual([
+      { kind: "text", value: "Visit " },
+      { kind: "link", value: "www.example.com/test", url: "https://www.example.com/test" },
+    ]);
+  });
+});

package/src/utils/link-tokenizer.ts

@@ -0,0 +1,93 @@
+export interface InlineLinkTextToken {
+  kind: "text";
+  value: string;
+}
+
+export interface InlineLinkUrlToken {
+  kind: "link";
+  value: string;
+  url: string;
+}
+
+export type InlineLinkToken = InlineLinkTextToken | InlineLinkUrlToken;
+
+const LINK_TOKEN_RE = /\b(?:https?:\/\/|www\.)[^\s<>"']+/gi;
+const ALWAYS_TRIM_RE = /[.,!?;:]/;
+const BRACKET_PAIRS: Record<string, string> = {
+  ")": "(",
+  "]": "[",
+  "}": "{",
+};
+
+function countChar(value: string, char: string): number {
+  let total = 0;
+  for (const current of value) {
+    if (current === char) total += 1;
+  }
+  return total;
+}
+
+function trimTrailingLinkPunctuation(rawValue: string): { value: string; trailing: string } {
+  let value = rawValue;
+
+  while (value.length > 0) {
+    const lastChar = value[value.length - 1]!;
+    if (ALWAYS_TRIM_RE.test(lastChar)) {
+      value = value.slice(0, -1);
+      continue;
+    }
+
+    const openingChar = BRACKET_PAIRS[lastChar];
+    if (!openingChar) break;
+
+    if (countChar(value, lastChar) > countChar(value, openingChar)) {
+      value = value.slice(0, -1);
+      continue;
+    }
+
+    break;
+  }
+
+  return { value, trailing: rawValue.slice(value.length) };
+}
+
+function normalizeLinkUrl(value: string): string {
+  return /^https?:\/\//i.test(value) ? value : `https://${value}`;
+}
+
+export function tokenizeInlineLinks(text: string): InlineLinkToken[] {
+  const tokens: InlineLinkToken[] = [];
+  let cursor = 0;
+  let match: RegExpExecArray | null;
+
+  LINK_TOKEN_RE.lastIndex = 0;
+  while ((match = LINK_TOKEN_RE.exec(text)) !== null) {
+    const rawValue = match[0];
+    const start = match.index;
+    const end = start + rawValue.length;
+
+    if (start > cursor) {
+      tokens.push({ kind: "text", value: text.slice(cursor, start) });
+    }
+
+    const trimmed = trimTrailingLinkPunctuation(rawValue);
+    if (trimmed.value) {
+      tokens.push({
+        kind: "link",
+        value: trimmed.value,
+        url: normalizeLinkUrl(trimmed.value),
+      });
+    }
+    if (trimmed.trailing) {
+      tokens.push({ kind: "text", value: trimmed.trailing });
+    }
+
+    cursor = end;
+  }
+
+  if (cursor < text.length) {
+    tokens.push({ kind: "text", value: text.slice(cursor) });
+  }
+
+  return tokens;
+}

package/src/utils/market-format.test.ts

@@ -0,0 +1,109 @@
+import { describe, expect, test } from "bun:test";
+import {
+  formatMarketCost,
+  formatMarketCostWithCurrency,
+  formatCompactMarketPriceWithCurrency,
+  formatMarketPrice,
+  formatMarketPriceWithCurrency,
+  formatMarketQuantity,
+  formatSignedMarketPrice,
+  resolveAssetDisplayKind,
+} from "./market-format";
+
+describe("resolveAssetDisplayKind", () => {
+  test("prefers explicit cash balances", () => {
+    expect(resolveAssetDisplayKind({ isCashBalance: true, assetCategory: "STK" })).toBe("cash");
+  });
+
+  test("maps common broker security types", () => {
+    expect(resolveAssetDisplayKind({ assetCategory: "CRYPTO" })).toBe("crypto");
+    expect(resolveAssetDisplayKind({ assetCategory: "STK" })).toBe("equity");
+    expect(resolveAssetDisplayKind({ contractSecType: "OPT" })).toBe("contract");
+    expect(resolveAssetDisplayKind({ assetCategory: "FOREX" })).toBe("cash");
+    expect(resolveAssetDisplayKind({ assetCategory: "CURRENCY" })).toBe("cash");
+    expect(resolveAssetDisplayKind({ assetCategory: "CCY" })).toBe("cash");
+  });
+
+  test("falls back to contract formatting when only a multiplier is present", () => {
+    expect(resolveAssetDisplayKind({ multiplier: 100 })).toBe("contract");
+  });
+});
+
+describe("formatMarketQuantity", () => {
+  test("preserves additional FX precision while trimming trailing zeroes", () => {
+    expect(formatMarketQuantity(-351957.025, { isCashBalance: true })).toBe("-351,957.025");
+    expect(formatMarketQuantity(-303029.144938754, { isCashBalance: true })).toBe("-303,029.144939");
+  });
+
+  test("shows whole equities without decimals and fractional equities with up to four decimals", () => {
+    expect(formatMarketQuantity(10, { assetCategory: "STK" })).toBe("10");
+    expect(formatMarketQuantity(10.125, { assetCategory: "STK" })).toBe("10.125");
+    expect(formatMarketQuantity(10.123456, { assetCategory: "STK" })).toBe("10.1235");
+  });
+
+  test("uses higher precision for crypto quantities", () => {
+    expect(formatMarketQuantity(0.123456789, { assetCategory: "CRYPTO" })).toBe("0.12345679");
+  });
+});
+
+describe("formatMarketPrice", () => {
+  test("uses semantic precision for equities, cash, and crypto", () => {
+    expect(formatMarketPrice(190.2, { assetCategory: "STK" })).toBe("190.2");
+    expect(formatMarketPrice(259.7499, { assetCategory: "STK" })).toBe("259.75");
+    expect(formatMarketPrice(1.084567, { isCashBalance: true })).toBe("1.084567");
+    expect(formatMarketPrice(1.17364, { assetCategory: "CURRENCY" })).toBe("1.17364");
+    expect(formatMarketPrice(0.000123456789, { assetCategory: "CRYPTO" })).toBe("0.00012346");
+  });
+
+  test("can adapt chart precision to the visible price range", () => {
+    expect(formatMarketPrice(1.167815, { assetCategory: "CURRENCY", priceRange: 0.12 })).toBe("1.17");
+    expect(formatMarketPrice(1.167815, { assetCategory: "CURRENCY", priceRange: 0.0024 })).toBe("1.1678");
+    expect(formatMarketPrice(259.7499, {
+      assetCategory: "STK",
+      minimumFractionDigits: 2,
+      precisionOffset: 1,
+      priceRange: 80,
+    })).toBe("259.75");
+  });
+
+  test("can lock price displays to a specific number of decimals", () => {
+    expect(formatMarketPrice(18, { assetCategory: "STK", fixedFractionDigits: 1 })).toBe("18.0");
+    expect(formatMarketPriceWithCurrency(18, "USD", { assetCategory: "STK", fixedFractionDigits: 2 })).toBe("$18.00");
+  });
+
+  test("fits within the supplied width before falling back to truncation elsewhere", () => {
+    expect(formatMarketPrice(1.084567, { isCashBalance: true, maxWidth: 6 })).toBe("1.0846");
+    expect(formatMarketQuantity(123456.789, { assetCategory: "CRYPTO", maxWidth: 7 })).toBe("123,457");
+  });
+
+  test("formats signed price changes without double signs", () => {
+    expect(formatSignedMarketPrice(0.123456, { isCashBalance: true })).toBe("+0.123456");
+    expect(formatSignedMarketPrice(-0.123456, { isCashBalance: true })).toBe("-0.123456");
+  });
+});
+
+describe("formatMarketCost", () => {
+  test("keeps equity cost displays conservative while preserving FX and crypto precision", () => {
+    expect(formatMarketCost(119.3687, { assetCategory: "STK" })).toBe("119.37");
+    expect(formatMarketCost(1.084567, { isCashBalance: true })).toBe("1.084567");
+    expect(formatMarketCost(113905.720075, { assetCategory: "CRYPTO" })).toBe("113,905.720075");
+  });
+});
+
+describe("formatMarketPriceWithCurrency", () => {
+  test("renders price-like values with a symbol and variable decimals", () => {
+    expect(formatMarketPriceWithCurrency(190.25, "USD", { assetCategory: "STK" })).toBe("$190.25");
+    expect(formatMarketPriceWithCurrency(1.084567, "EUR", { isCashBalance: true })).toBe("€1.084567");
+    expect(formatMarketPriceWithCurrency(1.17364, "USD", { assetCategory: "CURRENCY" })).toBe("$1.17364");
+  });
+
+  test("preserves chart-style compact notation for large values", () => {
+    expect(formatCompactMarketPriceWithCurrency(21_970, "JPY")).toBe("¥22.0K");
+    expect(formatCompactMarketPriceWithCurrency(12_340, "HKD")).toBe("HK$12.3K");
+  });
+
+  test("formats position cost values with tighter equity precision", () => {
+    expect(formatMarketCostWithCurrency(119.3687, "HKD", { assetCategory: "STK" })).toBe("HK$119.37");
+    expect(formatMarketCostWithCurrency(50.9507, "USD", { assetCategory: "OPT", multiplier: 100 })).toBe("$50.9507");
+  });
+});