gloomberb 0.5.0 → 0.6.0

package/src/sources/sec-edgar.ts

@@ -1,4 +1,3 @@
-import { hostname } from "os";
 import type { SecFilingItem } from "../types/data-provider";
 
 const LOOKUP_URL = "https://www.sec.gov/files/company_tickers_exchange.json";
@@ -19,14 +18,28 @@ function extractEmail(value: string | undefined): string | null {
   return match?.[0] ?? null;
 }
 
+function getEnv(name: string): string | undefined {
+  return typeof process !== "undefined" ? process.env[name] : undefined;
+}
+
+function getRuntimeHostName(): string {
+  const maybeLocation = (globalThis as { location?: { hostname?: string } }).location;
+  if (maybeLocation?.hostname) {
+    return maybeLocation.hostname;
+  }
+  return "localhost";
+}
+
+const runtimeHostName = getRuntimeHostName();
+
 const DEFAULT_SEC_FROM =
-  process.env.SEC_FROM_EMAIL?.trim()
-  || extractEmail(process.env.SEC_USER_AGENT)
-  || `${sanitizeIdentityPart(process.env.USER ?? "gloomberb", "gloomberb")}@${sanitizeIdentityPart(`${hostname()}.local`, "localhost.localdomain")}`;
+  getEnv("SEC_FROM_EMAIL")?.trim()
+  || extractEmail(getEnv("SEC_USER_AGENT"))
+  || `${sanitizeIdentityPart(getEnv("USER") ?? "gloomberb", "gloomberb")}@${sanitizeIdentityPart(`${runtimeHostName}.local`, "localhost.localdomain")}`;
 
 export const DEFAULT_SEC_USER_AGENT =
-  process.env.SEC_USER_AGENT?.trim()
-  || `Gloomberb/0.1 (${sanitizeIdentityPart(hostname(), "localhost")}; contact=${DEFAULT_SEC_FROM})`;
+  getEnv("SEC_USER_AGENT")?.trim()
+  || `Gloomberb/0.1 (${sanitizeIdentityPart(runtimeHostName, "localhost")}; contact=${DEFAULT_SEC_FROM})`;
 
 type LookupEntry = {
   cik: string;

package/src/sources/yahoo-finance.test.ts

@@ -12,11 +12,6 @@ describe("YahooFinanceClient exchange aliases", () => {
     expect(provider.getSymbolsToTry("HY9H", "FWB2")).toEqual(["HY9H.F", "HY9H.DE"]);
   });
 
-  test("reports its manual chart resolution capabilities", () => {
-    const provider = new YahooFinanceClient();
-    expect(provider.getChartResolutionCapabilities()).toEqual(["5m", "15m", "1h", "1d", "1wk", "1mo"]);
-  });
-
   test("maps manual resolution requests to yahoo chart range plus interval", async () => {
     const provider = new YahooFinanceClient() as any;
     let request: { symbol: string; range: string; interval: string } | null = null;

package/src/sources/yahoo-finance.ts

@@ -1,4 +1,4 @@
-import type { Quote, Fundamentals, FinancialStatement, PricePoint, TickerFinancials, MarketState, OptionContract, OptionsChain, CompanyProfile } from "../types/financials";
+import type { Quote, Fundamentals, FinancialStatement, PricePoint, TickerFinancials, MarketState, OptionContract, OptionsChain, CompanyProfile, HolderData, HolderRecord, AnalystResearchData, AnalystEstimateRecord } from "../types/financials";
 import type { DataProvider, EarningsEvent, MarketDataRequestContext, NewsItem, SecFilingItem } from "../types/data-provider";
 import type { TimeRange } from "../components/chart/chart-types";
 import {
@@ -146,6 +146,63 @@ type TimeseriesResponse = { timeseries?: { result?: Array<Record<string, any>>;
 type QuoteSummaryResponse = {
   quoteSummary?: {
     result?: Array<{
+      price?: {
+        symbol?: string;
+        currency?: string;
+        shortName?: string;
+        longName?: string;
+        exchangeName?: string;
+      };
+      financialData?: {
+        currentPrice?: { raw?: number } | number | null;
+        targetHighPrice?: { raw?: number } | number | null;
+        targetLowPrice?: { raw?: number } | number | null;
+        targetMeanPrice?: { raw?: number } | number | null;
+        targetMedianPrice?: { raw?: number } | number | null;
+        recommendationMean?: { raw?: number } | number | null;
+      };
+      recommendationTrend?: {
+        trend?: Array<{
+          period?: string;
+          strongBuy?: number;
+          buy?: number;
+          hold?: number;
+          sell?: number;
+          strongSell?: number;
+        }>;
+      };
+      upgradeDowngradeHistory?: {
+        history?: Array<{
+          epochGradeDate?: number;
+          firm?: string;
+          action?: string;
+          priceTargetAction?: string;
+          toGrade?: string;
+          fromGrade?: string;
+        }>;
+      };
+      earningsTrend?: {
+        trend?: Array<{
+          period?: string;
+          endDate?: string;
+          earningsEstimate?: {
+            avg?: { raw?: number } | number | null;
+            low?: { raw?: number } | number | null;
+            high?: { raw?: number } | number | null;
+            yearAgoEps?: { raw?: number } | number | null;
+            numberOfAnalysts?: { raw?: number } | number | null;
+            growth?: { raw?: number } | number | null;
+          };
+          revenueEstimate?: {
+            avg?: { raw?: number } | number | null;
+            low?: { raw?: number } | number | null;
+            high?: { raw?: number } | number | null;
+            yearAgoRevenue?: { raw?: number } | number | null;
+            numberOfAnalysts?: { raw?: number } | number | null;
+            growth?: { raw?: number } | number | null;
+          };
+        }>;
+      };
       assetProfile?: {
         longBusinessSummary?: string;
         sector?: string;
@@ -161,10 +218,28 @@ type QuoteSummaryResponse = {
         dayHigh?: { raw?: number } | number | null;
         dayLow?: { raw?: number } | number | null;
       };
+      majorHoldersBreakdown?: {
+        insidersPercentHeld?: { raw?: number } | number | null;
+        institutionsPercentHeld?: { raw?: number } | number | null;
+        institutionsFloatPercentHeld?: { raw?: number } | number | null;
+        institutionsCount?: { raw?: number } | number | null;
+      };
+      institutionOwnership?: {
+        ownershipList?: Array<{
+          organization?: string;
+          reportDate?: { raw?: number; fmt?: string } | number | string | null;
+          position?: { raw?: number } | number | null;
+          value?: { raw?: number } | number | null;
+          pctHeld?: { raw?: number } | number | null;
+          pctChange?: { raw?: number } | number | null;
+        }>;
+      };
     }>;
     error?: { description?: string } | null;
   };
 };
+type YahooQuoteSummaryResult = NonNullable<NonNullable<QuoteSummaryResponse["quoteSummary"]>["result"]>[number];
+type YahooEarningsTrend = NonNullable<NonNullable<YahooQuoteSummaryResult["earningsTrend"]>["trend"]>[number];
 
 const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
 
@@ -195,6 +270,168 @@ function financeRawNumber(value: unknown): number | undefined {
   return undefined;
 }
 
+function financeRawNumberOrNull(value: unknown): number | null {
+  return financeRawNumber(value) ?? null;
+}
+
+function hasAnalystResearchValue(data: AnalystResearchData): boolean {
+  return !!data.priceTarget
+    || data.recommendations.length > 0
+    || data.ratings.length > 0
+    || data.earningsEstimates.length > 0
+    || data.revenueEstimates.length > 0;
+}
+
+function normalizeYahooRecommendationPeriod(period?: string): string {
+  switch (period) {
+    case "0m":
+      return "current month";
+    case "-1m":
+      return "previous month";
+    case "-2m":
+      return "previous 2 months";
+    case "-3m":
+      return "previous 3 months";
+    case "0q":
+      return "current quarter";
+    case "+1q":
+      return "next quarter";
+    case "0y":
+      return "current year";
+    case "+1y":
+      return "next year";
+    default:
+      return period ?? "";
+  }
+}
+
+function normalizeYahooRatingAction(action?: string, priceTargetAction?: string): string | undefined {
+  const targetAction = priceTargetAction?.trim();
+  switch ((action ?? "").toLowerCase()) {
+    case "up":
+      return "Upgrade";
+    case "down":
+      return "Downgrade";
+    case "init":
+      return "Initiated";
+    case "reit":
+      return targetAction || "Reiterated";
+    case "main":
+      return targetAction || "Maintained";
+    default:
+      return action?.trim() || undefined;
+  }
+}
+
+function yahooRecommendationMeanToRating(value: number | undefined): number | undefined {
+  if (value == null) return undefined;
+  return Math.max(0, Math.min(10, ((5 - value) / 4) * 10));
+}
+
+function mapYahooEstimate(
+  trend: YahooEarningsTrend,
+  estimate: unknown,
+  yearAgoKey: "yearAgoEps" | "yearAgoRevenue",
+): AnalystEstimateRecord | null {
+  if (!estimate || typeof estimate !== "object") return null;
+  const record = estimate as Record<string, unknown>;
+  const average = financeRawNumber(record.avg);
+  const low = financeRawNumber(record.low);
+  const high = financeRawNumber(record.high);
+  const analysts = financeRawNumber(record.numberOfAnalysts);
+  const yearAgo = financeRawNumber(record[yearAgoKey]);
+  const growth = financeRawNumber(record.growth);
+  if (
+    average == null
+    && low == null
+    && high == null
+    && analysts == null
+    && yearAgo == null
+    && growth == null
+  ) {
+    return null;
+  }
+  return {
+    date: trend.endDate ?? "",
+    period: normalizeYahooRecommendationPeriod(trend.period),
+    analysts,
+    average,
+    low,
+    high,
+    yearAgo,
+    growth,
+  };
+}
+
+function mapYahooAnalystResearchResponse(
+  result: YahooQuoteSummaryResult,
+  fallbackSymbol: string,
+): AnalystResearchData {
+  const financialData = result.financialData;
+  const targetHigh = financeRawNumber(financialData?.targetHighPrice);
+  const targetLow = financeRawNumber(financialData?.targetLowPrice);
+  const targetMean = financeRawNumber(financialData?.targetMeanPrice);
+  const targetMedian = financeRawNumber(financialData?.targetMedianPrice);
+  const currentPrice = financeRawNumber(financialData?.currentPrice);
+  const trend = result.earningsTrend?.trend ?? [];
+
+  return {
+    providerId: "yahoo",
+    symbol: result.price?.symbol ?? fallbackSymbol,
+    name: result.price?.shortName ?? result.price?.longName,
+    currency: result.price?.currency,
+    exchange: result.price?.exchangeName,
+    priceTarget: targetHigh != null || targetLow != null || targetMean != null || targetMedian != null
+      ? {
+          high: targetHigh,
+          median: targetMedian,
+          low: targetLow,
+          average: targetMean,
+          current: currentPrice,
+          currency: result.price?.currency,
+        }
+      : undefined,
+    recommendationRating: yahooRecommendationMeanToRating(financeRawNumber(financialData?.recommendationMean)),
+    recommendations: (result.recommendationTrend?.trend ?? [])
+      .filter((row) => row.period)
+      .map((row) => ({
+        period: normalizeYahooRecommendationPeriod(row.period),
+        strongBuy: row.strongBuy,
+        buy: row.buy,
+        hold: row.hold,
+        sell: row.sell,
+        strongSell: row.strongSell,
+      })),
+    ratings: (result.upgradeDowngradeHistory?.history ?? [])
+      .map((rating): AnalystResearchData["ratings"][number] | null => {
+        const firm = rating.firm?.trim();
+        const date = rating.epochGradeDate
+          ? new Date(rating.epochGradeDate * 1000).toISOString().slice(0, 10)
+          : "";
+        if (!firm || !date) return null;
+        const action = normalizeYahooRatingAction(rating.action, rating.priceTargetAction);
+        const current = rating.toGrade?.trim();
+        const prior = rating.fromGrade?.trim();
+        return {
+          date,
+          firm,
+          ...(action ? { action } : {}),
+          ...(current ? { current } : {}),
+          ...(prior ? { prior } : {}),
+        };
+      })
+      .filter((rating): rating is AnalystResearchData["ratings"][number] => rating !== null)
+      .sort((left, right) => right.date.localeCompare(left.date))
+      .slice(0, 100),
+    earningsEstimates: trend
+      .map((row) => mapYahooEstimate(row, row.earningsEstimate, "yearAgoEps"))
+      .filter((estimate): estimate is AnalystEstimateRecord => estimate !== null),
+    revenueEstimates: trend
+      .map((row) => mapYahooEstimate(row, row.revenueEstimate, "yearAgoRevenue"))
+      .filter((estimate): estimate is AnalystEstimateRecord => estimate !== null),
+  };
+}
+
 function normalizePositiveMarketValue(value: number | undefined, divisor = 1): number | undefined {
   if (value == null || !Number.isFinite(value) || value <= 0) return undefined;
   return value / divisor;
@@ -205,6 +442,39 @@ function normalizeMarketValue(value: number | undefined, divisor = 1): number |
   return value / divisor;
 }
 
+function yahooRawDateTime(value: unknown): Date | null {
+  const raw = financeRawNumber(value);
+  if (raw == null) return null;
+  const date = new Date(raw * 1000);
+  return Number.isNaN(date.getTime()) ? null : date;
+}
+
+function inferEarningsTiming(date: Date): EarningsEvent["timing"] {
+  const hour = date.getUTCHours();
+  if (hour >= 20) return "AMC";
+  if (hour <= 13) return "BMO";
+  return "";
+}
+
+function yahooRawDate(value: unknown): string | undefined {
+  if (value && typeof value === "object") {
+    const fmt = (value as { fmt?: unknown }).fmt;
+    if (typeof fmt === "string" && /^\d{4}-\d{2}-\d{2}$/.test(fmt)) return fmt;
+  }
+  if (typeof value === "string" && /^\d{4}-\d{2}-\d{2}$/.test(value)) return value;
+  const raw = financeRawNumber(value);
+  if (raw == null) return undefined;
+  const date = new Date(raw * 1000);
+  return Number.isNaN(date.getTime()) ? undefined : date.toISOString().slice(0, 10);
+}
+
+function deriveShareChange(position: number | undefined, changePercent: number | undefined): number | undefined {
+  if (position == null || changePercent == null || !Number.isFinite(position) || !Number.isFinite(changePercent)) return undefined;
+  const denominator = 1 + changePercent;
+  if (denominator <= 0) return undefined;
+  return Math.round(position - position / denominator);
+}
+
 function deriveMarketState(meta: NonNullable<ChartResult["meta"]>): MarketState {
   const ctp = meta.currentTradingPeriod;
   if (!ctp) return "CLOSED";
@@ -269,10 +539,7 @@ function extractExtendedHoursPrices(
 
 // Cache TTLs
 const QUOTE_TTL = 5 * 60_000; // 5 min
-const FUNDAMENTALS_TTL = 60 * 60_000; // 1 hour
 const HISTORY_TTL = 24 * 60 * 60_000; // 24 hours
-const NEWS_TTL = 15 * 60_000; // 15 min
-const OPTIONS_TTL = 5 * 60_000; // 5 min
 const INTRADAY_HISTORY_TTL = 5 * 60_000; // 5 min for intraday ranges
 
 // Maps TimeRange → Yahoo API { range, interval } for optimal granularity
@@ -691,7 +958,7 @@ export class YahooFinanceClient implements DataProvider {
       listingExchangeFullName: meta.fullExchangeName,
       marketState,
       sessionConfidence: "derived",
-      dataSource: "yahoo",
+      dataSource: "delayed",
       ...quoteSupplement,
       ...extHours,
     };
@@ -833,7 +1100,7 @@ export class YahooFinanceClient implements DataProvider {
           listingExchangeFullName: meta.fullExchangeName,
           marketState,
           sessionConfidence: "derived",
-          dataSource: "yahoo",
+          dataSource: "delayed",
           ...quoteSupplement,
           ...extHours,
         };
@@ -910,6 +1177,95 @@ export class YahooFinanceClient implements DataProvider {
     }
   }
 
+  async getHolders(ticker: string, exchange = "", _context?: MarketDataRequestContext): Promise<HolderData> {
+    const symbolsToTry = this.getSymbolsToTry(ticker, exchange);
+    let lastError: any;
+
+    for (const symbol of symbolsToTry) {
+      try {
+        const params = new URLSearchParams({
+          modules: "price,majorHoldersBreakdown,institutionOwnership",
+        });
+        const url = `https://query1.finance.yahoo.com/v10/finance/quoteSummary/${encodeURIComponent(symbol)}?${params}`;
+        const data = await this.fetchJsonWithCrumb<QuoteSummaryResponse>(`holders ${symbol}`, url);
+        const result = data.quoteSummary?.result?.[0];
+        if (!result) throw new Error(`No holder data for ${symbol}`);
+
+        const holders: HolderRecord[] = (result.institutionOwnership?.ownershipList ?? [])
+          .map((item): HolderRecord | null => {
+            const name = item.organization?.trim();
+            if (!name) return null;
+            const shares = financeRawNumber(item.position);
+            const changePercent = financeRawNumber(item.pctChange);
+            return {
+              providerId: this.id,
+              ownerType: "institution",
+              name,
+              reportDate: yahooRawDate(item.reportDate),
+              shares,
+              value: financeRawNumber(item.value),
+              percentHeld: financeRawNumber(item.pctHeld),
+              changePercent,
+              changeShares: deriveShareChange(shares, changePercent),
+            };
+          })
+          .filter((holder): holder is HolderRecord => holder !== null);
+        const asOf = holders
+          .map((holder) => holder.reportDate)
+          .filter((date): date is string => !!date)
+          .sort()
+          .at(-1);
+
+        return {
+          providerId: this.id,
+          symbol: result.price?.symbol ?? symbol,
+          name: result.price?.shortName ?? result.price?.longName,
+          currency: result.price?.currency,
+          exchange: result.price?.exchangeName,
+          asOf,
+          summary: {
+            insidersPercentHeld: financeRawNumber(result.majorHoldersBreakdown?.insidersPercentHeld),
+            institutionsPercentHeld: financeRawNumber(result.majorHoldersBreakdown?.institutionsPercentHeld),
+            institutionsFloatPercentHeld: financeRawNumber(result.majorHoldersBreakdown?.institutionsFloatPercentHeld),
+            institutionsCount: financeRawNumber(result.majorHoldersBreakdown?.institutionsCount),
+          },
+          holders,
+        };
+      } catch (err) {
+        lastError = err;
+      }
+    }
+
+    throw lastError || new Error(`No holder data for ${ticker}`);
+  }
+
+  async getAnalystResearch(ticker: string, exchange = "", _context?: MarketDataRequestContext): Promise<AnalystResearchData> {
+    const symbolsToTry = this.getSymbolsToTry(ticker, exchange);
+    let firstEmpty: AnalystResearchData | null = null;
+    let lastError: any;
+
+    for (const symbol of symbolsToTry) {
+      try {
+        const params = new URLSearchParams({
+          modules: "price,financialData,recommendationTrend,upgradeDowngradeHistory,earningsTrend",
+        });
+        const url = `https://query1.finance.yahoo.com/v10/finance/quoteSummary/${encodeURIComponent(symbol)}?${params}`;
+        const data = await this.fetchJsonWithCrumb<QuoteSummaryResponse>(`analyst research ${symbol}`, url);
+        const result = data.quoteSummary?.result?.[0];
+        if (!result) throw new Error(`No analyst data for ${symbol}`);
+
+        const research = mapYahooAnalystResearchResponse(result, symbol);
+        if (hasAnalystResearchValue(research)) return research;
+        firstEmpty ??= research;
+      } catch (err) {
+        lastError = err;
+      }
+    }
+
+    if (firstEmpty) return firstEmpty;
+    throw lastError || new Error(`No analyst data for ${ticker}`);
+  }
+
   async getSecFilings(ticker: string, count = 10, _exchange = "", _context?: MarketDataRequestContext): Promise<SecFilingItem[]> {
     return this.secClient.getRecentFilings(ticker, count);
   }
@@ -1084,15 +1440,46 @@ export class YahooFinanceClient implements DataProvider {
                 calendarEvents?: {
                   earnings?: {
                     earningsDate?: Array<{ raw: number }>;
+                    earningsCallDate?: Array<{ raw: number }>;
+                    isEarningsDateEstimate?: boolean;
                     earningsAverage?: { raw: number };
+                    earningsLow?: { raw: number };
+                    earningsHigh?: { raw: number };
                     revenueAverage?: { raw: number };
+                    revenueLow?: { raw: number };
+                    revenueHigh?: { raw: number };
                   };
                 };
                 earningsTrend?: {
                   trend?: Array<{
                     period: string;
-                    earningsEstimate?: { avg?: { raw: number } };
-                    revenueEstimate?: { avg?: { raw: number } };
+                    earningsEstimate?: {
+                      avg?: { raw: number };
+                      low?: { raw: number };
+                      high?: { raw: number };
+                      yearAgoEps?: { raw: number };
+                      numberOfAnalysts?: { raw: number };
+                      growth?: { raw: number };
+                    };
+                    revenueEstimate?: {
+                      avg?: { raw: number };
+                      low?: { raw: number };
+                      high?: { raw: number };
+                      yearAgoRevenue?: { raw: number };
+                      numberOfAnalysts?: { raw: number };
+                      growth?: { raw: number };
+                    };
+                    epsTrend?: {
+                      current?: { raw: number };
+                      "7daysAgo"?: { raw: number };
+                      "30daysAgo"?: { raw: number };
+                    };
+                    epsRevisions?: {
+                      upLast7days?: { raw: number };
+                      upLast30days?: { raw: number };
+                      downLast7Days?: { raw: number };
+                      downLast30days?: { raw: number };
+                    };
                   }>;
                 };
                 quoteType?: {
@@ -1113,18 +1500,40 @@ export class YahooFinanceClient implements DataProvider {
           if (isNaN(earningsDate.getTime())) return null;
 
           const currentQtr = mod.earningsTrend?.trend?.find((t) => t.period === "0q");
+          const earningsEstimate = currentQtr?.earningsEstimate;
+          const revenueEstimate = currentQtr?.revenueEstimate;
+          const epsTrend = currentQtr?.epsTrend;
+          const epsRevisions = currentQtr?.epsRevisions;
           const name = mod.quoteType?.shortName || mod.quoteType?.longName || symbol;
 
           return {
             symbol,
             name,
             earningsDate,
-            epsEstimate: currentQtr?.earningsEstimate?.avg?.raw ?? cal.earningsAverage?.raw ?? null,
+            earningsCallDate: yahooRawDateTime(cal.earningsCallDate?.[0]),
+            isDateEstimate: cal.isEarningsDateEstimate ?? null,
+            epsEstimate: financeRawNumberOrNull(earningsEstimate?.avg ?? cal.earningsAverage),
+            epsLow: financeRawNumberOrNull(earningsEstimate?.low ?? cal.earningsLow),
+            epsHigh: financeRawNumberOrNull(earningsEstimate?.high ?? cal.earningsHigh),
+            epsYearAgo: financeRawNumberOrNull(earningsEstimate?.yearAgoEps),
+            epsGrowth: financeRawNumberOrNull(earningsEstimate?.growth),
+            epsAnalysts: financeRawNumberOrNull(earningsEstimate?.numberOfAnalysts),
+            epsTrend7dAgo: financeRawNumberOrNull(epsTrend?.["7daysAgo"]),
+            epsTrend30dAgo: financeRawNumberOrNull(epsTrend?.["30daysAgo"]),
+            epsRevisionUp7d: financeRawNumberOrNull(epsRevisions?.upLast7days),
+            epsRevisionUp30d: financeRawNumberOrNull(epsRevisions?.upLast30days),
+            epsRevisionDown7d: financeRawNumberOrNull(epsRevisions?.downLast7Days),
+            epsRevisionDown30d: financeRawNumberOrNull(epsRevisions?.downLast30days),
             epsActual: null,
-            revenueEstimate: currentQtr?.revenueEstimate?.avg?.raw ?? cal.revenueAverage?.raw ?? null,
+            revenueEstimate: financeRawNumberOrNull(revenueEstimate?.avg ?? cal.revenueAverage),
+            revenueLow: financeRawNumberOrNull(revenueEstimate?.low ?? cal.revenueLow),
+            revenueHigh: financeRawNumberOrNull(revenueEstimate?.high ?? cal.revenueHigh),
+            revenueYearAgo: financeRawNumberOrNull(revenueEstimate?.yearAgoRevenue),
+            revenueGrowth: financeRawNumberOrNull(revenueEstimate?.growth),
+            revenueAnalysts: financeRawNumberOrNull(revenueEstimate?.numberOfAnalysts),
             revenueActual: null,
             surprise: null,
-            timing: "" as const,
+            timing: inferEarningsTiming(earningsDate),
           };
         }),
       );

package/src/state/app-activity.ts

@@ -1,4 +1,4 @@
-import { CliRenderEvents, type CliRenderer } from "@opentui/core";
+import { type NativeRendererHost as CliRenderer } from "../ui";
 import { useSyncExternalStore } from "react";
 import { debugLog } from "../utils/debug-log";
 
@@ -36,15 +36,15 @@ class AppActivityController {
     };
     const handleDestroy = () => this.reset();
 
-    renderer.on(CliRenderEvents.FOCUS, handleFocus);
-    renderer.on(CliRenderEvents.BLUR, handleBlur);
-    renderer.on(CliRenderEvents.DESTROY, handleDestroy);
+    renderer.on("focus", handleFocus);
+    renderer.on("blur", handleBlur);
+    renderer.on("destroy", handleDestroy);
 
     this.boundRenderer = renderer;
     this.teardownRenderer = () => {
-      renderer.off(CliRenderEvents.FOCUS, handleFocus);
-      renderer.off(CliRenderEvents.BLUR, handleBlur);
-      renderer.off(CliRenderEvents.DESTROY, handleDestroy);
+      renderer.off("focus", handleFocus);
+      renderer.off("blur", handleBlur);
+      renderer.off("destroy", handleDestroy);
       if (this.boundRenderer === renderer) {
         this.boundRenderer = null;
         this.teardownRenderer = null;