gloomberb 0.5.0 → 0.6.0

package/src/utils/api-client.ts

@@ -1,11 +1,43 @@
-import type { CompanyProfile, Fundamentals, PricePoint, Quote, TickerFinancials } from "../types/financials";
+import type {
+  AnalystResearchData,
+  CompanyProfile,
+  CorporateActionsData,
+  Fundamentals,
+  HolderData,
+  HolderRecord,
+  PricePoint,
+  Quote,
+  TickerFinancials,
+} from "../types/financials";
 import type { InstrumentSearchResult } from "../types/instrument";
 import { debugLog } from "./debug-log";
+import { canonicalExchange, normalizeSymbol, publicTickerKey } from "./exchanges";
 import { normalizeTimestamp } from "./timestamp";
 
 const DEFAULT_API_URL = "https://api.gloom.sh";
 const SESSION_COOKIE_NAMES = ["__Secure-gloomberb.session_token", "gloomberb.session_token"] as const;
 const cloudApiLog = debugLog.createLogger("cloud-api");
+const HARD_SESSION_INVALID_PATTERNS = [
+  /\b(user|account)\b.*\b(not found|deleted|removed|disabled|deactivated|suspended)\b/i,
+  /\b(user|account)\b.*\bdoes(?:\s+not|n't)\s+exist\b/i,
+  /\b(no|unknown|missing)\s+(user|account)\b/i,
+];
+
+type CloudApiResponse = Pick<Response, "ok" | "status" | "headers" | "text">;
+type CloudApiFetchTransport = (url: string, init?: RequestInit) => Promise<CloudApiResponse>;
+
+let cloudApiFetchTransport: CloudApiFetchTransport = (url, init) => fetch(url, init);
+
+export function setCloudApiFetchTransport(transport: CloudApiFetchTransport | null): void {
+  cloudApiFetchTransport = transport ?? ((url, init) => fetch(url, init));
+}
+
+function getCloudApiBaseUrl(): string {
+  if (typeof process === "undefined") {
+    return DEFAULT_API_URL;
+  }
+  return process.env.GLOOMBERB_API_URL ?? DEFAULT_API_URL;
+}
 
 export interface ChatMessage {
   id: string;
@@ -48,6 +80,24 @@ export interface CloudCompanyProfile extends CompanyProfile {}
 
 export interface CloudFundamentals extends Fundamentals {}
 
+export interface CloudHolderPayload extends HolderRecord {
+  providerId: "gloomberb-cloud";
+  ownerType: "institution";
+}
+
+export interface CloudHoldersPayload extends HolderData {
+  providerId: "gloomberb-cloud";
+  holders: CloudHolderPayload[];
+}
+
+export interface CloudAnalystResearchPayload extends AnalystResearchData {
+  providerId: "gloomberb-cloud";
+}
+
+export interface CloudCorporateActionsPayload extends CorporateActionsData {
+  providerId: "gloomberb-cloud";
+}
+
 export interface CloudPricePointPayload {
   date: string;
   open?: number;
@@ -57,6 +107,178 @@ export interface CloudPricePointPayload {
   volume?: number;
 }
 
+export type CloudEconImpact = "high" | "medium" | "low";
+
+export interface CloudEconEventPayload {
+  id: string;
+  date: string;
+  time: string;
+  country: string;
+  event: string;
+  actual: string | null;
+  forecast: string | null;
+  prior: string | null;
+  impact: CloudEconImpact;
+}
+
+export interface CloudFredObservationPayload {
+  date: string;
+  value: number | null;
+}
+
+export interface CloudFredSeriesInfoPayload {
+  id: string;
+  title: string;
+  units: string;
+  frequency: string;
+  seasonalAdjustment: string;
+  source: string;
+  notes: string;
+}
+
+export interface CloudFredSeriesPayload {
+  observations: CloudFredObservationPayload[];
+  info: CloudFredSeriesInfoPayload | null;
+}
+
+export interface CloudYieldPointPayload {
+  maturity: string;
+  maturityYears: number;
+  yield: number | null;
+}
+
+export interface CloudNewsEntityPayload {
+  id: string;
+  entityType: string;
+  name: string;
+  symbol: string | null;
+  exchange: string | null;
+  canonicalTicker: string | null;
+  role: string | null;
+  confidence: number | null;
+}
+
+export interface CloudNewsTickerLinkPayload {
+  symbol: string;
+  exchange: string;
+  canonicalTicker: string;
+  relationType: string;
+  displayTier: "primary" | "related";
+  confidence: number;
+  relevanceScore: number;
+  impactScore?: number;
+  sentiment?: "positive" | "neutral" | "negative" | null;
+}
+
+export interface CloudNewsStoryItemPayload {
+  id: string;
+  sourceKey: string;
+  sourceName: string;
+  title: string;
+  summary?: string;
+  url: string;
+  publishedAt: string;
+  hasArticleText?: boolean;
+}
+
+export interface CloudNewsPayload {
+  id: string;
+  headline: string;
+  summary: string;
+  topic?: string;
+  topics?: string[];
+  category: string;
+  sentiment: "positive" | "neutral" | "negative";
+  sectors: string[];
+  scope?: string;
+  firstPublishedAt: string;
+  lastPublishedAt: string;
+  firstSeenAt: string;
+  lastSeenAt: string;
+  primaryUrl: string;
+  primarySource: string;
+  scores?: {
+    importance?: number;
+    urgency?: number;
+    marketImpact?: number;
+    novelty?: number;
+    confidence?: number;
+  };
+  flags?: {
+    breaking?: boolean;
+    developing?: boolean;
+    stale?: boolean;
+  };
+  variantCount: number;
+  sourceCount: number;
+  sources: string[];
+  entities: CloudNewsEntityPayload[];
+  tickerLinks: CloudNewsTickerLinkPayload[];
+  items?: CloudNewsStoryItemPayload[];
+}
+
+export interface CloudNewsListResponse {
+  items: CloudNewsPayload[];
+  nextCursor: string | null;
+}
+
+export interface CloudTweetUserPayload {
+  id: string;
+  userName: string;
+  name: string;
+}
+
+export interface CloudTweetMetricsPayload {
+  retweets: number | null;
+  replies: number | null;
+  likes: number | null;
+  quotes: number | null;
+  views: number | null;
+  bookmarks: number | null;
+}
+
+export interface CloudTweetMediaPayload {
+  type?: string;
+  url?: string;
+  mediaUrl?: string;
+  media_url?: string;
+  media_url_https?: string;
+  previewImageUrl?: string;
+  preview_image_url?: string;
+}
+
+export interface CloudTweetPayload {
+  id: string;
+  url: string;
+  text: string;
+  createdAt: string;
+  lang: string;
+  isReply: boolean;
+  author: CloudTweetUserPayload;
+  metrics: CloudTweetMetricsPayload;
+  media?: CloudTweetMediaPayload[];
+  photos?: CloudTweetMediaPayload[];
+  images?: CloudTweetMediaPayload[];
+}
+
+export type CloudTweetQueryType = "Latest" | "Top";
+
+export interface CloudTweetSearchResponse {
+  ticker?: string;
+  cashtag?: string;
+  query: string;
+  queryType: CloudTweetQueryType;
+  since: string;
+  until: string;
+  limit: number;
+  hours: number;
+  includeReplies?: boolean;
+  cached: boolean;
+  cacheTtlMs: number;
+  asOf: string;
+  tweets: CloudTweetPayload[];
+}
+
 export type CloudMarketStatus =
   | "success"
   | "partial"
@@ -95,17 +317,9 @@ export interface QuoteStreamTarget {
   exchange?: string;
 }
 
-function normalizeSymbol(value: string): string {
-  return value.trim().toUpperCase();
-}
-
-function normalizeExchange(value?: string): string {
-  return (value ?? "").trim().toUpperCase();
-}
-
 function marketKey(symbol: string, exchange?: string): string {
   const normalizedSymbolValue = normalizeSymbol(symbol);
-  const normalizedExchangeValue = normalizeExchange(exchange);
+  const normalizedExchangeValue = canonicalExchange(exchange);
   return normalizedExchangeValue ? `${normalizedSymbolValue}:${normalizedExchangeValue}` : normalizedSymbolValue;
 }
 
@@ -120,6 +334,23 @@ function normalizeChatMessages(messages: ChatMessage[]): ChatMessage[] {
   return messages.map((message) => normalizeChatMessage(message));
 }
 
+function normalizeTweet(tweet: CloudTweetPayload): CloudTweetPayload {
+  return {
+    ...tweet,
+    createdAt: normalizeTimestamp(tweet.createdAt),
+  };
+}
+
+function normalizeTweetSearchResponse(response: CloudTweetSearchResponse): CloudTweetSearchResponse {
+  return {
+    ...response,
+    since: normalizeTimestamp(response.since),
+    until: normalizeTimestamp(response.until),
+    asOf: normalizeTimestamp(response.asOf),
+    tweets: response.tweets.map(normalizeTweet),
+  };
+}
+
 type ChannelListener = (message: ChatMessage) => void;
 type QuoteListener = (target: QuoteStreamTarget, quote: CloudQuotePayload) => void;
 type SessionCookieName = (typeof SESSION_COOKIE_NAMES)[number];
@@ -131,6 +362,22 @@ class ApiRequestError extends Error {
   }
 }
 
+function parseApiErrorMessage(body: string): string {
+  try {
+    const parsed = JSON.parse(body) as Record<string, unknown>;
+    const parts = [parsed.message, parsed.error, parsed.code, parsed.reason]
+      .filter((value): value is string => typeof value === "string" && value.trim().length > 0);
+    return parts.join(" ") || body;
+  } catch {
+    return body;
+  }
+}
+
+function isHardSessionInvalidMessage(message: string): boolean {
+  const normalized = message.replace(/[_-]+/g, " ");
+  return HARD_SESSION_INVALID_PATTERNS.some((pattern) => pattern.test(normalized));
+}
+
 class GloomApiClient {
   private sessionToken: string | null = null;
   private sessionCookieName: SessionCookieName | null = null;
@@ -147,7 +394,7 @@ class GloomApiClient {
   private readonly quoteTargets = new Map<string, QuoteStreamTarget>();
 
   constructor() {
-    this.baseUrl = process.env.GLOOMBERB_API_URL ?? DEFAULT_API_URL;
+    this.baseUrl = getCloudApiBaseUrl();
   }
 
   getSessionToken(): string | null {
@@ -213,6 +460,13 @@ class GloomApiClient {
     this.ensureSocket();
   }
 
+  private requireCapturedSession(message: string): void {
+    if (this.sessionToken) return;
+    this.websocketToken = null;
+    this.setCurrentUser(null);
+    throw new Error(message);
+  }
+
   private extractSessionCookie(res: Response): void {
     const setCookie = res.headers.getSetCookie?.() ?? [];
     const fallbackHeader = res.headers.get("set-cookie");
@@ -252,7 +506,7 @@ class GloomApiClient {
     this.setSessionCookieHeader(headers);
     headers.set("Origin", this.baseUrl);
 
-    const res = await fetch(`${this.baseUrl}${path}`, {
+    const res = await cloudApiFetchTransport(`${this.baseUrl}${path}`, {
       ...options,
       headers,
       credentials: "include",
@@ -262,12 +516,7 @@ class GloomApiClient {
 
     if (!res.ok) {
       const body = await res.text();
-      let msg: string;
-      try {
-        msg = JSON.parse(body).message ?? body;
-      } catch {
-        msg = body;
-      }
+      const msg = parseApiErrorMessage(body);
       throw new ApiRequestError(msg, res.status);
     }
 
@@ -300,10 +549,11 @@ class GloomApiClient {
 
     const socketToken = this.getSocketAuthToken();
     if (!socketToken) return;
+    const usingWebSocketToken = !!this.websocketToken;
     const url = `${this.getWebSocketBaseUrl()}/cloud/ws?token=${encodeURIComponent(socketToken)}`;
     cloudApiLog.info("open websocket", {
       hasToken: !!socketToken,
-      tokenSource: this.websocketToken ? "websocket" : "session",
+      tokenSource: usingWebSocketToken ? "websocket" : "session",
       quoteTargets: this.quoteTargets.size,
       channelTargets: this.channelListeners.size,
     });
@@ -321,11 +571,24 @@ class GloomApiClient {
       void this.handleSocketMessage(String(event.data));
     };
 
-    ws.onclose = () => {
+    ws.onclose = (event) => {
+      const activeSocket = this.ws === ws;
       if (this.ws === ws) {
         this.ws = null;
       }
-      cloudApiLog.warn("websocket closed", { quoteTargets: this.quoteTargets.size, channelTargets: this.channelListeners.size });
+      const closeEvent = event as CloseEvent | undefined;
+      cloudApiLog.warn("websocket closed", {
+        quoteTargets: this.quoteTargets.size,
+        channelTargets: this.channelListeners.size,
+        code: closeEvent?.code,
+        reason: closeEvent?.reason,
+        tokenSource: usingWebSocketToken ? "websocket" : "session",
+      });
+      if (activeSocket && usingWebSocketToken && this.sessionToken) {
+        this.websocketToken = null;
+        this.reconnectDelayMs = 1000;
+        cloudApiLog.warn("cleared websocket token after socket close; falling back to session token");
+      }
       if (!this.shouldKeepSocketOpen()) return;
       this.scheduleReconnect();
     };
@@ -410,6 +673,14 @@ class GloomApiClient {
 
     if (parsed?.type === "auth.unverified") {
       cloudApiLog.warn("websocket marked unverified");
+      if (this.websocketToken && this.sessionToken) {
+        this.websocketToken = null;
+        this.reconnectDelayMs = 1000;
+        cloudApiLog.warn("cleared websocket token after auth rejection; falling back to session token");
+        this.teardownSocket();
+        this.scheduleReconnect();
+        return;
+      }
       if (this.currentUser) {
         this.currentUser = { ...this.currentUser, emailVerified: false };
       }
@@ -429,7 +700,7 @@ class GloomApiClient {
       const key = marketKey(parsed.symbol, parsed.exchange);
       const target = this.quoteTargets.get(key) ?? {
         symbol: normalizeSymbol(parsed.symbol),
-        exchange: normalizeExchange(parsed.exchange),
+        exchange: canonicalExchange(parsed.exchange),
       };
       for (const listener of this.quoteListeners.get(key) ?? []) {
         listener(target, parsed.quote as CloudQuotePayload);
@@ -446,43 +717,51 @@ class GloomApiClient {
   }
 
   async signUp(email: string, username: string, name: string, password: string): Promise<AuthUser> {
-    const result = await this.request<{ user: AuthUser }>("/api/auth/api/auth/sign-up/email", {
+    const result = await this.request<{ user: AuthUser }>("/auth/sign-up/email", {
       method: "POST",
       body: JSON.stringify({ email, username, name, password }),
     });
+    this.requireCapturedSession(
+      "Account created, but Gloomberb could not save the login session. Please try logging in again.",
+    );
     this.setCurrentUser(result.user);
     return result.user;
   }
 
   async signIn(email: string, password: string): Promise<AuthUser> {
-    const result = await this.request<{ user: AuthUser }>("/api/auth/api/auth/sign-in/email", {
+    const result = await this.request<{ user: AuthUser }>("/auth/sign-in/email", {
       method: "POST",
       body: JSON.stringify({ email, password }),
     });
+    this.requireCapturedSession(
+      "Logged in, but Gloomberb could not save the login session. Please try again.",
+    );
     this.setCurrentUser(result.user);
     return result.user;
   }
 
   async signOut(): Promise<void> {
-    await this.request("/api/auth/api/auth/sign-out", { method: "POST" });
-    this.sessionToken = null;
-    this.setCurrentUser(null);
+    try {
+      await this.request("/auth/sign-out", { method: "POST" });
+    } finally {
+      this.setSessionToken(null);
+    }
   }
 
   async getSession(): Promise<AuthUser | null> {
     try {
-      const result = await this.request<{ user: AuthUser }>("/api/auth/api/auth/get-session", {
+      const result = await this.request<{ user: AuthUser }>("/auth/get-session", {
         method: "GET",
       });
       const user = result?.user ?? null;
       this.setCurrentUser(user);
       return user;
     } catch (error) {
-      if (!(error instanceof ApiRequestError) || (error.status !== 401 && error.status !== 403)) {
-        throw error;
+      if (error instanceof ApiRequestError && isHardSessionInvalidMessage(error.message)) {
+        this.setSessionToken(null);
+        return null;
       }
-      this.setCurrentUser(null);
-      return null;
+      throw error;
     }
   }
 
@@ -576,7 +855,7 @@ class GloomApiClient {
         .map((target) => {
           const normalized = {
             symbol: normalizeSymbol(target.symbol),
-            exchange: normalizeExchange(target.exchange),
+            exchange: canonicalExchange(target.exchange),
           } satisfies QuoteStreamTarget;
           return [marketKey(normalized.symbol, normalized.exchange), normalized] as const;
         }),
@@ -686,6 +965,24 @@ class GloomApiClient {
     return this.request<CloudMarketResponse<CloudFundamentals>>(`/market/fundamentals?${params.toString()}`);
   }
 
+  async getCloudHolders(symbol: string, exchange?: string): Promise<CloudMarketResponse<CloudHoldersPayload>> {
+    const params = new URLSearchParams({ symbol });
+    if (exchange) params.set("exchange", exchange);
+    return this.request<CloudMarketResponse<CloudHoldersPayload>>(`/market/holders?${params.toString()}`);
+  }
+
+  async getCloudAnalystResearch(symbol: string, exchange?: string): Promise<CloudMarketResponse<CloudAnalystResearchPayload>> {
+    const params = new URLSearchParams({ symbol });
+    if (exchange) params.set("exchange", exchange);
+    return this.request<CloudMarketResponse<CloudAnalystResearchPayload>>(`/market/analyst?${params.toString()}`);
+  }
+
+  async getCloudCorporateActions(symbol: string, exchange?: string): Promise<CloudMarketResponse<CloudCorporateActionsPayload>> {
+    const params = new URLSearchParams({ symbol });
+    if (exchange) params.set("exchange", exchange);
+    return this.request<CloudMarketResponse<CloudCorporateActionsPayload>>(`/market/corporate-actions?${params.toString()}`);
+  }
+
   async getCloudStatements(
     symbol: string,
     exchange?: string,
@@ -720,6 +1017,109 @@ class GloomApiClient {
     const params = new URLSearchParams({ fromCurrency });
     return this.request<CloudMarketResponse<{ rate: number }>>(`/market/exchange-rate?${params.toString()}`);
   }
+
+  async getCloudEconomicCalendar(): Promise<CloudEconEventPayload[]> {
+    return this.request<CloudEconEventPayload[]>("/cloud/econ/calendar");
+  }
+
+  async getCloudFredSeries(
+    seriesId: string,
+    params: {
+      startDate?: string;
+      endDate?: string;
+      limit?: number;
+      sortOrder?: "asc" | "desc";
+    } = {},
+  ): Promise<CloudFredSeriesPayload> {
+    const search = new URLSearchParams();
+    if (params.startDate) search.set("startDate", params.startDate);
+    if (params.endDate) search.set("endDate", params.endDate);
+    if (params.limit != null) search.set("limit", String(params.limit));
+    if (params.sortOrder) search.set("sortOrder", params.sortOrder);
+    const qs = search.toString();
+    return this.request<CloudFredSeriesPayload>(`/cloud/econ/series/${encodeURIComponent(seriesId)}${qs ? `?${qs}` : ""}`);
+  }
+
+  async getCloudYieldCurve(): Promise<CloudYieldPointPayload[]> {
+    return this.request<CloudYieldPointPayload[]>("/cloud/econ/yield-curve");
+  }
+
+  async getCloudNews(params: {
+    feed?: "latest" | "top" | "breaking" | "ticker" | "sector" | "topic";
+    ticker?: string;
+    exchange?: string;
+    tickerTier?: "primary" | "related" | "any";
+    tickerRelations?: string[];
+    limit?: number;
+    topics?: string[];
+    categories?: string[];
+    sectors?: string[];
+    sources?: string[];
+    excludeSources?: string[];
+    sentiment?: "positive" | "neutral" | "negative";
+    minImportance?: number;
+    minUrgency?: number;
+    breaking?: boolean;
+    since?: Date;
+    until?: Date;
+    cursor?: string;
+  } = {}): Promise<CloudNewsListResponse> {
+    const search = new URLSearchParams();
+    if (params.feed) search.set("feed", params.feed);
+    if (params.ticker) {
+      const tickerFilter = params.exchange
+        ? publicTickerKey(params.ticker, params.exchange)
+        : normalizeSymbol(params.ticker);
+      search.set("tickers", tickerFilter);
+    }
+    if (params.tickerTier) search.set("tickerTier", params.tickerTier);
+    if (params.tickerRelations?.length) search.set("tickerRelations", params.tickerRelations.join(","));
+    if (params.limit != null) search.set("limit", String(params.limit));
+    if (params.topics?.length) search.set("topics", params.topics.join(","));
+    if (params.categories?.length) {
+      search.set("categories", params.categories.join(","));
+    }
+    if (params.sectors?.length) search.set("sectors", params.sectors.join(","));
+    if (params.sources?.length) search.set("sources", params.sources.join(","));
+    if (params.excludeSources?.length) search.set("excludeSources", params.excludeSources.join(","));
+    if (params.sentiment) search.set("sentiment", params.sentiment);
+    if (params.minImportance != null) search.set("minImportance", String(params.minImportance));
+    if (params.minUrgency != null) search.set("minUrgency", String(params.minUrgency));
+    if (params.breaking != null) search.set("breaking", String(params.breaking));
+    if (params.since) search.set("since", params.since.toISOString());
+    if (params.until) search.set("until", params.until.toISOString());
+    if (params.cursor) search.set("cursor", params.cursor);
+    const query = search.toString();
+    return this.request<CloudNewsListResponse>(`/news${query ? `?${query}` : ""}`);
+  }
+
+  async getCloudTickerTweets(params: {
+    ticker: string;
+    limit?: number;
+    hours?: number;
+    includeReplies?: boolean;
+  }): Promise<CloudTweetSearchResponse> {
+    const search = new URLSearchParams({ ticker: params.ticker });
+    if (params.limit != null) search.set("limit", String(params.limit));
+    if (params.hours != null) search.set("hours", String(params.hours));
+    if (params.includeReplies != null) search.set("includeReplies", String(params.includeReplies));
+    const response = await this.request<CloudTweetSearchResponse>(`/news/tweets?${search.toString()}`);
+    return normalizeTweetSearchResponse(response);
+  }
+
+  async searchCloudTweets(params: {
+    query: string;
+    queryType?: CloudTweetQueryType;
+    limit?: number;
+    hours?: number;
+  }): Promise<CloudTweetSearchResponse> {
+    const search = new URLSearchParams({ query: params.query });
+    if (params.queryType) search.set("queryType", params.queryType);
+    if (params.limit != null) search.set("limit", String(params.limit));
+    if (params.hours != null) search.set("hours", String(params.hours));
+    const response = await this.request<CloudTweetSearchResponse>(`/news/tweets/search?${search.toString()}`);
+    return normalizeTweetSearchResponse(response);
+  }
 }
 
 export const apiClient = new GloomApiClient();

package/src/utils/back-navigation.ts

@@ -25,3 +25,9 @@ export function isPlainEscape(event: BackNavigationEventLike): boolean {
 export function isBackNavigationKey(event: BackNavigationEventLike): boolean {
   return isPlainBackspace(event) || isPlainEscape(event);
 }
+
+export function isDetailBackNavigationKey(
+  event: BackNavigationEventLike,
+): boolean {
+  return isPlainBackspace(event);
+}

package/src/utils/cli-output.ts

@@ -1,3 +1,4 @@
+
 export type CliAlign = "left" | "right" | "center";
 
 export interface CliTableColumn {

package/src/utils/currency-units.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import { hasLikelyQuoteUnitMismatch, normalizePriceValueByDivisor, resolveCurrencyUnit } from "./currency-units";
+import { hasLikelyQuoteUnitMismatch, resolveCurrencyUnit } from "./currency-units";
 
 describe("currency unit helpers", () => {
   test("normalizes known sub-unit currencies to their main currency", () => {
@@ -7,11 +7,6 @@ describe("currency unit helpers", () => {
     expect(resolveCurrencyUnit("GBP")).toEqual({ currency: "GBP", divisor: 1 });
   });
 
-  test("scales quote prices by the configured divisor", () => {
-    expect(normalizePriceValueByDivisor(23.1, 100)).toBeCloseTo(0.231, 8);
-    expect(normalizePriceValueByDivisor(125, 1)).toBe(125);
-  });
-
   test("detects sub-unit quotes that match the same main-currency price", () => {
     expect(hasLikelyQuoteUnitMismatch(
       { price: 23.1, currency: "GBp" },

package/src/utils/currency-units.ts

@@ -1,3 +1,4 @@
+
 const SUB_UNIT_CURRENCIES: Record<string, { currency: string; divisor: number }> = {
   GBp: { currency: "GBP", divisor: 100 },
   GBX: { currency: "GBP", divisor: 100 },