gloomberb 0.7.2 → 0.7.4

package/src/utils/exchanges.test.ts

@@ -0,0 +1,16 @@
+import { describe, expect, test } from "bun:test";
+import { CANONICAL_EXCHANGE_ALIASES, EXCHANGE_TIME_ZONES } from "./exchanges";
+
+describe("exchange metadata", () => {
+  test("has a valid timezone for every canonical exchange", () => {
+    const canonicalExchanges = [...new Set(Object.values(CANONICAL_EXCHANGE_ALIASES))].sort();
+    const missing = canonicalExchanges.filter((exchange) => !EXCHANGE_TIME_ZONES[exchange]);
+
+    expect(missing).toEqual([]);
+    for (const exchange of canonicalExchanges) {
+      expect(() => new Intl.DateTimeFormat("en-US", {
+        timeZone: EXCHANGE_TIME_ZONES[exchange],
+      })).not.toThrow();
+    }
+  });
+});

package/src/utils/exchanges.ts

@@ -31,6 +31,7 @@ export const CANONICAL_EXCHANGE_ALIASES: Record<string, string> = {
   TSX: "TSX",
   XTSE: "TSX",
   TSXV: "TSXV",
+  VAN: "TSXV",
   CN: "CSE",
   CNSX: "CSE",
   CSE: "CSE",
@@ -118,6 +119,7 @@ export const CANONICAL_EXCHANGE_ALIASES: Record<string, string> = {
   XJSE: "JSE",
   TLV: "TASE",
   XTAE: "TASE",
+  CCC: "CCC",
 };
 
 export const PUBLIC_EXCHANGE_ALIASES: Record<string, string> = {
@@ -128,6 +130,8 @@ export const PUBLIC_EXCHANGE_ALIASES: Record<string, string> = {
   HKEX: "XHKG",
   LSE: "XLON",
   TSX: "XTSE",
+  TSXV: "XTSX",
+  CSE: "XCNQ",
   ASX: "XASX",
   NZX: "XNZE",
   SWX: "XSWX",
@@ -172,6 +176,21 @@ export const EXCHANGE_TIME_ZONES: Record<string, string> = {
   SFB: "Europe/Stockholm",
   HKEX: "Asia/Hong_Kong",
   JPX: "Asia/Tokyo",
+  TSX: "America/Toronto",
+  TSXV: "America/Toronto",
+  CSE: "America/Toronto",
+  EPA: "Europe/Paris",
+  AMS: "Europe/Amsterdam",
+  BRU: "Europe/Brussels",
+  LIS: "Europe/Lisbon",
+  BIT: "Europe/Rome",
+  HEL: "Europe/Helsinki",
+  CPH: "Europe/Copenhagen",
+  OSL: "Europe/Oslo",
+  ICEX: "Atlantic/Reykjavik",
+  WSE: "Europe/Warsaw",
+  PSE: "Europe/Prague",
+  VIE: "Europe/Vienna",
   TPEX: "Asia/Taipei",
   TWSE: "Asia/Taipei",
   NSE: "Asia/Kolkata",
@@ -181,6 +200,15 @@ export const EXCHANGE_TIME_ZONES: Record<string, string> = {
   SGX: "Asia/Singapore",
   KRX: "Asia/Seoul",
   KOSDAQ: "Asia/Seoul",
+  NZX: "Pacific/Auckland",
+  SSE: "Asia/Shanghai",
+  SZSE: "Asia/Shanghai",
+  BMV: "America/Mexico_City",
+  B3: "America/Sao_Paulo",
+  BYMA: "America/Argentina/Buenos_Aires",
+  JSE: "Africa/Johannesburg",
+  TASE: "Asia/Jerusalem",
+  CCC: "UTC",
 };
 
 export function normalizeSymbol(value: string): string {
@@ -196,6 +224,11 @@ export function canonicalExchange(value?: string): string {
   return CANONICAL_EXCHANGE_ALIASES[normalized] ?? normalized;
 }
 
+export function resolveExchangeTimeZone(value?: string): string | null {
+  const canonical = canonicalExchange(value);
+  return canonical ? EXCHANGE_TIME_ZONES[canonical] ?? null : null;
+}
+
 export function publicExchange(value?: string): string {
   const canonical = canonicalExchange(value);
   return PUBLIC_EXCHANGE_ALIASES[canonical] ?? canonical;

package/src/utils/fuzzy-search.ts

@@ -5,7 +5,18 @@ export function fuzzyMatch(query: string, target: string): { match: boolean; sco
   const t = target.toLowerCase();
 
   if (q.length === 0) return { match: true, score: 0 };
-  if (t.startsWith(q)) return { match: true, score: 1000 - q.length }; // exact prefix match
+  if (t === q) return { match: true, score: 2500 - q.length };
+
+  const tokens = t.split(/\s+/).filter(Boolean);
+  const exactTokenIndex = tokens.findIndex((token) => token === q);
+  if (exactTokenIndex >= 0) return { match: true, score: 2200 - q.length - exactTokenIndex };
+
+  const prefixTokenIndex = tokens.findIndex((token) => token.startsWith(q));
+  if (prefixTokenIndex >= 0) {
+    const token = tokens[prefixTokenIndex]!;
+    return { match: true, score: 1000 - q.length - prefixTokenIndex - (token.length - q.length) };
+  }
+
   if (t.includes(q)) return { match: true, score: 500 - q.length }; // substring match
 
   let qi = 0;

package/src/utils/keyboard.ts

@@ -0,0 +1,31 @@
+export interface KeyboardModifierEventLike {
+  ctrl?: boolean;
+  meta?: boolean;
+  super?: boolean;
+  alt?: boolean;
+  option?: boolean;
+  shift?: boolean;
+  name?: string;
+}
+
+export function hasKeyboardModifier(event: KeyboardModifierEventLike): boolean {
+  return !!(
+    event.ctrl
+    || event.meta
+    || event.super
+    || event.alt
+    || event.option
+    || event.shift
+  );
+}
+
+export function isPlainKeyboardEvent(event: KeyboardModifierEventLike): boolean {
+  return !hasKeyboardModifier(event);
+}
+
+export function isPlainKey(
+  event: KeyboardModifierEventLike,
+  ...names: string[]
+): boolean {
+  return isPlainKeyboardEvent(event) && names.includes(event.name ?? "");
+}

package/src/utils/options.ts

@@ -23,7 +23,7 @@ export function parseOptionSymbol(symbol: string): { underlying: string; expTs:
   const year = 2000 + parseInt(yy!, 10);
   const month = parseInt(mm!, 10) - 1;
   const day = parseInt(dd!, 10);
-  const expTs = Math.floor(new Date(year, month, day).getTime() / 1000);
+  const expTs = Math.floor(Date.UTC(year, month, day) / 1000);
   return { underlying: underlying!, expTs, strike, side: side as "C" | "P" };
 }
 

package/src/utils/price-history.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import { normalizePriceHistory } from "./price-history";
+import { isPriceHistoryStaleForCurrentWindow, normalizePriceHistory } from "./price-history";
 
 describe("normalizePriceHistory", () => {
   test("drops poisoned cached history when every timestamp collapses to the same value", () => {
@@ -22,4 +22,31 @@ describe("normalizePriceHistory", () => {
 
     expect(history.map((point) => point.close)).toEqual([101, 102, 103]);
   });
+
+  test("drops zero-price bars instead of treating missing upstream prices as real data", () => {
+    const history = normalizePriceHistory([
+      { date: new Date("2026-05-13T13:30:00Z"), close: 64 },
+      { date: new Date("2026-05-13T13:45:00Z"), close: 0 },
+      { date: new Date("2026-05-13T14:00:00Z"), close: Number.NaN },
+      { date: new Date("2026-05-13T14:15:00Z"), close: 65 },
+    ]);
+
+    expect(history.map((point) => point.close)).toEqual([64, 65]);
+  });
+
+  test("detects intraday history that is old even when the cache record is fresh", () => {
+    expect(
+      isPriceHistoryStaleForCurrentWindow(
+        [{ date: new Date("2026-04-17T20:00:00Z"), close: 67 }],
+        Date.parse("2026-05-13T23:00:00Z"),
+      ),
+    ).toBe(true);
+
+    expect(
+      isPriceHistoryStaleForCurrentWindow(
+        [{ date: new Date("2026-05-13T22:45:00Z"), close: 67 }],
+        Date.parse("2026-05-13T23:00:00Z"),
+      ),
+    ).toBe(false);
+  });
 });

package/src/utils/price-history.ts

@@ -1,5 +1,7 @@
 import type { PricePoint, TickerFinancials } from "../types/financials";
 
+const MAX_CURRENT_INTRADAY_HISTORY_LAG_MS = 18 * 60 * 60 * 1000;
+
 function getPointTimestamp(point: PricePoint): number {
   const value = point.date as Date | string | number | null | undefined;
   if (value instanceof Date) return value.getTime();
@@ -7,6 +9,10 @@ function getPointTimestamp(point: PricePoint): number {
   return new Date(value).getTime();
 }
 
+function hasValidClose(point: PricePoint): boolean {
+  return Number.isFinite(point.close) && point.close > 0;
+}
+
 function comparePricePointsByDate(left: PricePoint, right: PricePoint): number {
   const leftTime = getPointTimestamp(left);
   const rightTime = getPointTimestamp(right);
@@ -31,6 +37,7 @@ export function normalizePriceHistory(points: PricePoint[]): PricePoint[] {
   for (const point of points) {
     const time = getPointTimestamp(point);
     if (!Number.isFinite(time)) continue;
+    if (!hasValidClose(point)) continue;
 
     if (firstTimestamp === null) {
       firstTimestamp = time;
@@ -55,6 +62,15 @@ export function normalizePriceHistory(points: PricePoint[]): PricePoint[] {
   return validPoints.length === points.length ? points : validPoints;
 }
 
+export function isPriceHistoryStaleForCurrentWindow(points: PricePoint[], now = Date.now()): boolean {
+  const normalized = normalizePriceHistory(points);
+  const latest = normalized.at(-1);
+  if (!latest) return false;
+
+  const latestTime = getPointTimestamp(latest);
+  return Number.isFinite(latestTime) && now - latestTime > MAX_CURRENT_INTRADAY_HISTORY_LAG_MS;
+}
+
 export function normalizeTickerFinancialsPriceHistory(financials: TickerFinancials): TickerFinancials {
   const priceHistory = normalizePriceHistory(financials.priceHistory ?? []);
   return priceHistory === financials.priceHistory

package/src/utils/quote-freshness.test.ts

@@ -0,0 +1,150 @@
+import { describe, expect, test } from "bun:test";
+import type { Quote } from "../types/financials";
+import { isQuoteStaleForCurrentSession } from "./quote-freshness";
+
+function quote(overrides: Partial<Quote>): Quote {
+  return {
+    symbol: "2337",
+    price: 168,
+    currency: "TWD",
+    change: 0,
+    changePercent: 0,
+    lastUpdated: Date.parse("2026-05-08T06:00:00Z"),
+    listingExchangeName: "TWSE",
+    exchangeName: "TWSE",
+    marketState: "CLOSED",
+    dataSource: "delayed",
+    ...overrides,
+  };
+}
+
+describe("quote freshness", () => {
+  test("treats multi-business-day-old non-US closed quotes as stale", () => {
+    expect(
+      isQuoteStaleForCurrentSession(
+        quote({}),
+        Date.parse("2026-05-13T21:00:00Z"),
+      ),
+    ).toBe(true);
+  });
+
+  test("treats stale Paris and Toronto quotes as refreshable", () => {
+    const now = Date.parse("2026-05-13T21:00:00Z");
+
+    expect(
+      isQuoteStaleForCurrentSession(
+        quote({
+          symbol: "ALRIB",
+          currency: "EUR",
+          lastUpdated: Date.parse("2026-05-08T15:30:00Z"),
+          listingExchangeName: "PAR",
+          exchangeName: "PAR",
+        }),
+        now,
+      ),
+    ).toBe(true);
+
+    expect(
+      isQuoteStaleForCurrentSession(
+        quote({
+          symbol: "HPS-A.TO",
+          currency: "CAD",
+          lastUpdated: Date.parse("2026-05-08T20:00:00Z"),
+          listingExchangeName: "TOR",
+          exchangeName: "TOR",
+        }),
+        now,
+      ),
+    ).toBe(true);
+  });
+
+  test("treats old crypto quotes as stale on the 24/7 venue", () => {
+    expect(
+      isQuoteStaleForCurrentSession(
+        quote({
+          symbol: "BTC-USD",
+          currency: "USD",
+          lastUpdated: Date.parse("2026-05-09T15:29:00Z"),
+          listingExchangeName: "CCC",
+          exchangeName: "CCC",
+          marketState: "REGULAR",
+        }),
+        Date.parse("2026-05-13T21:00:00Z"),
+      ),
+    ).toBe(true);
+  });
+
+  test("allows the previous local business day before the market reopens", () => {
+    expect(
+      isQuoteStaleForCurrentSession(
+        quote({
+          symbol: "1211",
+          currency: "HKD",
+          lastUpdated: Date.parse("2026-05-13T08:00:00Z"),
+          listingExchangeName: "SEHK",
+          exchangeName: "SEHK",
+        }),
+        Date.parse("2026-05-13T21:00:00Z"),
+      ),
+    ).toBe(false);
+  });
+
+  test("rejects previous-day weekday quotes that are older than a normal overnight close", () => {
+    expect(
+      isQuoteStaleForCurrentSession(
+        quote({
+          symbol: "285A.T",
+          currency: "JPY",
+          lastUpdated: Date.parse("2026-05-12T21:00:00Z"),
+          listingExchangeName: "JPX",
+          exchangeName: "JPX",
+        }),
+        Date.parse("2026-05-13T21:00:00Z"),
+      ),
+    ).toBe(true);
+
+    expect(
+      isQuoteStaleForCurrentSession(
+        quote({
+          symbol: "285A.T",
+          currency: "JPY",
+          lastUpdated: Date.parse("2026-05-13T06:24:00Z"),
+          listingExchangeName: "JPX",
+          exchangeName: "JPX",
+        }),
+        Date.parse("2026-05-13T21:00:00Z"),
+      ),
+    ).toBe(false);
+  });
+
+  test("allows Friday closes before Monday reopen", () => {
+    expect(
+      isQuoteStaleForCurrentSession(
+        quote({
+          symbol: "285A.T",
+          currency: "JPY",
+          lastUpdated: Date.parse("2026-05-08T06:24:00Z"),
+          listingExchangeName: "JPX",
+          exchangeName: "JPX",
+        }),
+        Date.parse("2026-05-10T21:00:00Z"),
+      ),
+    ).toBe(false);
+  });
+
+  test("treats prior-date regular-session quotes as stale immediately", () => {
+    expect(
+      isQuoteStaleForCurrentSession(
+        quote({
+          symbol: "HY9H",
+          currency: "EUR",
+          lastUpdated: Date.parse("2026-04-07T19:55:00Z"),
+          listingExchangeName: "FWB2",
+          exchangeName: "FWB2",
+          marketState: "REGULAR",
+        }),
+        Date.parse("2026-04-08T10:49:00Z"),
+      ),
+    ).toBe(true);
+  });
+});

package/src/utils/quote-freshness.ts

@@ -3,6 +3,8 @@ import { canonicalExchange, EXCHANGE_TIME_ZONES } from "./exchanges";
 
 const US_EXTENDED_HOURS_EXCHANGES = new Set(["NASDAQ", "NYSE", "AMEX", "ARCA", "BATS"]);
 const exchangeLocalDateFormatters = new Map<string, Intl.DateTimeFormat>();
+const MS_PER_DAY = 24 * 60 * 60 * 1000;
+const OVERNIGHT_CLOSE_MAX_AGE_MS = 20 * 60 * 60 * 1000;
 const usSessionFormatter = new Intl.DateTimeFormat("en-US", {
   timeZone: "America/New_York",
   weekday: "short",
@@ -43,6 +45,38 @@ function exchangeLocalDate(exchange: string, timestampMs: number): string | null
   return `${year}-${month}-${day}`;
 }
 
+function isoLocalDateToUtcDay(date: string): number | null {
+  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(date);
+  if (!match) return null;
+
+  const year = Number(match[1]);
+  const month = Number(match[2]);
+  const day = Number(match[3]);
+  if (!Number.isFinite(year) || !Number.isFinite(month) || !Number.isFinite(day)) return null;
+
+  return Math.floor(Date.UTC(year, month - 1, day) / MS_PER_DAY);
+}
+
+function localWeekdaysBetween(earlierDate: string, laterDate: string): number {
+  const earlierDay = isoLocalDateToUtcDay(earlierDate);
+  const laterDay = isoLocalDateToUtcDay(laterDate);
+  if (earlierDay == null || laterDay == null || laterDay <= earlierDay) return 0;
+
+  let weekdays = 0;
+  for (let day = earlierDay + 1; day <= laterDay; day += 1) {
+    const weekday = new Date(day * MS_PER_DAY).getUTCDay();
+    if (weekday !== 0 && weekday !== 6) {
+      weekdays += 1;
+    }
+  }
+  return weekdays;
+}
+
+function localWeekday(date: string): number | null {
+  const day = isoLocalDateToUtcDay(date);
+  return day == null ? null : new Date(day * MS_PER_DAY).getUTCDay();
+}
+
 function usSessionState(timestampMs: number): UsSessionState {
   const parts = usSessionFormatter.formatToParts(new Date(timestampMs));
 
@@ -85,9 +119,16 @@ export function isQuoteStaleForCurrentSession(quote: Quote | null | undefined, n
 
   if (isUsExtendedHoursExchange(exchange)) {
     const session = usSessionState(now);
-    return session === "PRE" || session === "REGULAR" || session === "POST";
+    if (session === "PRE" || session === "REGULAR" || session === "POST") {
+      return true;
+    }
   }
 
+  const weekdaysBehind = localWeekdaysBetween(quoteDate, currentDate);
+  if (weekdaysBehind > 1) return true;
+  if (weekdaysBehind === 1 && now - quote.lastUpdated > OVERNIGHT_CLOSE_MAX_AGE_MS) {
+    return localWeekday(currentDate) !== 1;
+  }
   return false;
 }
 

package/src/utils/quote-resolution.ts

@@ -30,6 +30,7 @@ const PRICE_FIELD_KEYS = [
   "low",
   "mark",
   "lastUpdated",
+  "receivedAt",
 ] as const;
 
 const SESSION_FIELD_KEYS = [
@@ -516,6 +517,7 @@ export function resolveCanonicalQuote(
     volume: resolved.volume as Quote["volume"],
     name: resolved.name as Quote["name"],
     lastUpdated: Number(resolved.lastUpdated ?? priceProvider?.lastUpdated ?? sessionProvider?.lastUpdated ?? now),
+    receivedAt: resolved.receivedAt as Quote["receivedAt"],
     exchangeName: resolved.exchangeName as Quote["exchangeName"],
     fullExchangeName: resolved.fullExchangeName as Quote["fullExchangeName"],
     listingExchangeName: resolved.listingExchangeName as Quote["listingExchangeName"],

package/src/utils/quote-time.test.ts

@@ -0,0 +1,34 @@
+import { describe, expect, test } from "bun:test";
+import { formatQuoteAge, formatQuoteAgeWithSource, getMostRecentQuoteUpdate } from "./quote-time";
+
+describe("quote-time", () => {
+  test("formats sub-second quote age in milliseconds", () => {
+    const now = 1_700_000_030_000;
+
+    expect(formatQuoteAge(now - 999, now)).toBe("999ms");
+    expect(formatQuoteAge(now, now)).toBe("0ms");
+    expect(formatQuoteAgeWithSource({
+      lastUpdated: now - 100,
+      dataSource: "delayed",
+    }, now)).toBe("◷100ms");
+  });
+
+  test("uses stream receipt time for displayed quote age when available", () => {
+    const now = 1_700_000_030_000;
+    const quote = {
+      lastUpdated: 1_700_000_000_000,
+      receivedAt: 1_700_000_029_000,
+    };
+
+    expect(formatQuoteAgeWithSource(quote, now)).toBe("1s");
+    expect(getMostRecentQuoteUpdate([quote], now)).toBe(1_700_000_029_000);
+  });
+
+  test("keeps delayed source marker while using receipt time for age", () => {
+    expect(formatQuoteAgeWithSource({
+      lastUpdated: 1_700_000_000_000,
+      receivedAt: 1_700_000_029_000,
+      dataSource: "delayed",
+    }, 1_700_000_030_000)).toBe("◷1s");
+  });
+});

package/src/utils/quote-time.ts

@@ -11,20 +11,33 @@ export function formatQuoteAge(lastUpdated: number | undefined, now = Date.now()
   const clamped = clampQuoteTimestamp(lastUpdated, now);
   if (clamped == null) return "—";
 
-  const ageSeconds = Math.max(0, (now - clamped) / 1000);
+  const ageMs = Math.max(0, now - clamped);
+  if (ageMs < 1000) return `${Math.floor(ageMs)}ms`;
+
+  const ageSeconds = ageMs / 1000;
   if (ageSeconds < 60) return `${Math.floor(ageSeconds)}s`;
   if (ageSeconds < 3600) return `${Math.floor(ageSeconds / 60)}m`;
   if (ageSeconds < 86400) return `${Math.floor(ageSeconds / 3600)}h`;
   return `${Math.floor(ageSeconds / 86400)}d`;
 }
 
+export function resolveQuoteAgeTimestamp(
+  quote: Pick<Quote, "lastUpdated" | "receivedAt"> | null | undefined,
+  now = Date.now(),
+): number | null {
+  if (!quote) return null;
+  const receivedAt = clampQuoteTimestamp(quote.receivedAt, now);
+  return receivedAt ?? clampQuoteTimestamp(quote.lastUpdated, now);
+}
+
 export function formatQuoteAgeWithSource(
-  quote: Pick<Quote, "lastUpdated" | "dataSource"> | null | undefined,
+  quote: Pick<Quote, "lastUpdated" | "receivedAt" | "dataSource"> | null | undefined,
   now = Date.now(),
 ): string {
   if (!quote) return "—";
 
-  const age = formatQuoteAge(quote.lastUpdated, now);
+  const timestamp = resolveQuoteAgeTimestamp(quote, now);
+  const age = timestamp == null ? "—" : formatQuoteAge(timestamp, now);
   if (age === "—") return age;
 
   const prefix = quote.dataSource === "delayed" ? "◷" : "";
@@ -32,12 +45,12 @@ export function formatQuoteAgeWithSource(
 }
 
 export function getMostRecentQuoteUpdate(
-  quotes: Iterable<Pick<Quote, "lastUpdated"> | null | undefined>,
+  quotes: Iterable<Pick<Quote, "lastUpdated" | "receivedAt"> | null | undefined>,
   now = Date.now(),
 ): number | null {
   let latest: number | null = null;
   for (const quote of quotes) {
-    const timestamp = clampQuoteTimestamp(quote?.lastUpdated, now);
+    const timestamp = resolveQuoteAgeTimestamp(quote, now);
     if (timestamp != null && (latest == null || timestamp > latest)) {
       latest = timestamp;
     }

package/src/utils/ticker-search.test.ts

@@ -82,7 +82,7 @@ describe("ticker-search utilities", () => {
       ]),
     });
 
-    expect(results.map((item) => item.id)).toEqual(["goto:AAPL", "search:APP"]);
+    expect(results.map((item) => item.id)).toEqual(["goto:AAPL", "search:APP:NASDAQ:TEST"]);
     expect(findExactTickerSearchMatch(results, "AAPL")?.id).toBe("goto:AAPL");
   });
 
@@ -97,7 +97,7 @@ describe("ticker-search utilities", () => {
       ]),
     });
 
-    expect(results.map((item) => item.id)).toEqual(["goto:AAPL", "search:APLE"]);
+    expect(results.map((item) => item.id)).toEqual(["goto:AAPL", "search:APLE:NASDAQ:TEST"]);
     expect(results[0]).toMatchObject({
       id: "goto:AAPL",
       detail: "Apple Inc",

package/src/utils/ticker-search.ts

@@ -140,7 +140,7 @@ export function createProviderTickerSearchCandidates(
     const symbol = getSearchResultSymbol(result);
     const saved = localTickers.has(symbol);
     return [{
-      id: `search:${result.symbol}`,
+      id: buildProviderCandidateId(result, symbol),
       label: symbol,
       symbol,
       detail: [result.name, result.brokerLabel, result.type].filter(Boolean).join(" | "),
@@ -357,6 +357,7 @@ export function rankTickerSearchItems<T extends Pick<TickerSearchRankableItem, "
         item,
         index,
         normalizedSymbol: normalizeSearchText(item.symbol || item.label),
+        symbolMatchRank: scoreSymbolMatchRank(intent, item),
         textScore,
         score: textScore + priorityScore + (textScore > 0 && saved ? 900 : 0),
       };
@@ -375,6 +376,7 @@ export function rankTickerSearchItems<T extends Pick<TickerSearchRankableItem, "
       return !matchedLocalSymbols.has(normalizedSymbol);
     })
     .sort((a, b) => {
+      if (b.symbolMatchRank !== a.symbolMatchRank) return b.symbolMatchRank - a.symbolMatchRank;
       if (b.score !== a.score) return b.score - a.score;
       const aSaved = isSavedSearchItem(a.item);
       const bSaved = isSavedSearchItem(b.item);
@@ -463,6 +465,16 @@ function buildProviderSearchResultKey(result: InstrumentSearchResult): string {
   ].join("|");
 }
 
+function buildProviderCandidateId(result: InstrumentSearchResult, symbol: string): string {
+  return [
+    "search",
+    normalizeTickerSymbol(symbol),
+    normalizeSearchText(result.exchange || result.primaryExchange || result.type || ""),
+    normalizeSearchText(result.currency || ""),
+    normalizeSearchText(result.providerId || ""),
+  ].filter(Boolean).join(":");
+}
+
 function getProviderHintRichness(result: InstrumentSearchResult): number {
   let score = 0;
   if (result.name) score += Math.min(120, result.name.length);
@@ -728,6 +740,41 @@ function scoreSearchAlias(intent: SearchQueryIntent, alias: string): number {
   return score;
 }
 
+function scoreSymbolMatchRank(
+  intent: SearchQueryIntent,
+  item: Pick<TickerSearchRankableItem, "label"> & Partial<TickerSearchRankableItem>,
+): number {
+  if (!intent.normalizedQuery && !intent.compactQuery) return 0;
+  const displaySymbol = normalizeSearchText(item.symbol || item.label);
+  const compactDisplaySymbol = compactSearchText(item.symbol || item.label);
+
+  if (
+    displaySymbol === intent.normalizedQuery
+    || (intent.compactQuery && compactDisplaySymbol === intent.compactQuery)
+  ) {
+    return 3;
+  }
+
+  const aliases = getItemSearchAliases(item);
+  if (aliases.some((alias) => {
+    const normalizedAlias = normalizeSearchText(alias);
+    const compactAlias = compactSearchText(alias);
+    return normalizedAlias === intent.normalizedQuery
+      || (intent.compactQuery && compactAlias === intent.compactQuery);
+  })) {
+    return 2;
+  }
+
+  if (
+    displaySymbol.startsWith(intent.normalizedQuery)
+    || (intent.compactQuery && compactDisplaySymbol.startsWith(intent.compactQuery))
+  ) {
+    return 1;
+  }
+
+  return 0;
+}
+
 function scoreAssetPreference(intent: SearchQueryIntent, instrumentClass?: TickerSearchInstrumentClass): number {
   const itemClass = instrumentClass || "other";
   if (!intent.assetPreference) {

package/src/version.ts

@@ -1 +1 @@
-export const VERSION = "0.7.2";
+export const VERSION = "0.7.4";