gloomberb 0.13.2 → 0.14.0

package/src/plugins/prediction-markets/capability.test.ts

@@ -1,281 +0,0 @@
-import { afterEach, expect, test } from "bun:test";
-import { setHttpFetchTransport } from "../../utils/http-transport";
-import {
-  predictionChartSeriesCapability,
-  predictionHistoryPoints,
-  predictionSeriesId,
-} from "./capability";
-import {
-  attachPredictionMarketsPersistence,
-  resetPredictionMarketsPersistence,
-} from "./services/fetch";
-import { MemoryPersistence } from "./test-helpers";
-import type { PredictionMarketSummary } from "./types";
-
-function json(value: unknown) {
-  return new Response(JSON.stringify(value), { status: 200 });
-}
-
-function identity(overrides: Partial<PredictionMarketSummary>): PredictionMarketSummary {
-  return {
-    venue: "polymarket",
-    marketId: "market-1",
-    eventId: "event-1",
-    ...overrides,
-  } as PredictionMarketSummary;
-}
-
-afterEach(() => {
-  setHttpFetchTransport(null);
-  resetPredictionMarketsPersistence();
-});
-
-test("prediction chart history restores persisted dates, drops invalid rows, and sorts observations", () => {
-  const points = predictionHistoryPoints([
-    { date: "2026-02-02T00:00:00Z" as unknown as Date, close: 0.6 },
-    { date: new Date("invalid"), close: 0.9 },
-    { date: "2026-02-01T00:00:00Z" as unknown as Date, close: 0.4, open: 0.3 },
-  ], "polymarket");
-
-  expect(points.map((point) => [point.date.toISOString(), point.value])).toEqual([
-    ["2026-02-01T00:00:00.000Z", 0.4],
-    ["2026-02-02T00:00:00.000Z", 0.6],
-  ]);
-  expect(points[0]).toMatchObject({ open: 0.3, provenance: { providerId: "polymarket", quality: "reported" } });
-});
-
-test("stable prediction IDs retain provider lookup identity", () => {
-  expect(predictionSeriesId(identity({ venue: "kalshi", eventTicker: "EVT-1", marketId: "MKT-1" })))
-    .toBe("kalshi/EVT-1/MKT-1");
-  expect(predictionSeriesId(identity({ venue: "polymarket", eventId: "123", marketId: "456" })))
-    .toBe("polymarket/123/456");
-  expect(predictionSeriesId(identity({ venue: "polymarket", eventId: undefined }))).toBeNull();
-});
-
-test("catalog limit bounds provider search hydration", async () => {
-  const requested: string[] = [];
-  setHttpFetchTransport(async (url) => {
-    requested.push(url);
-    if (url.includes("public-search")) {
-      return json({ events: Array.from({ length: 5 }, (_, index) => ({ id: `event-${index + 1}` })) });
-    }
-    if (url.includes("gamma-api.polymarket.com/events/event-")) {
-      const eventId = url.split("/").at(-1)!;
-      return json({
-        id: eventId,
-        title: `Rates ${eventId}`,
-        markets: [{
-          id: `market-${eventId}`,
-          question: `Rates ${eventId}`,
-          active: true,
-          closed: false,
-          outcomes: ["Yes", "No"],
-          outcomePrices: ["0.5", "0.5"],
-          clobTokenIds: [`yes-${eventId}`, `no-${eventId}`],
-        }],
-      });
-    }
-    if (url.includes("api.elections.kalshi.com/trade-api/v2/events")) {
-      return json({ events: [] });
-    }
-    throw new Error(`Unexpected URL ${url}`);
-  });
-
-  const items = await predictionChartSeriesCapability.provider.search!({ query: "rates", limit: 2 });
-
-  expect(items).toHaveLength(2);
-  expect(requested.filter((url) => url.includes("gamma-api.polymarket.com/events/event-"))).toHaveLength(2);
-  expect(requested.some((url) => url.includes("api.elections.kalshi.com") && url.includes("limit=20"))).toBe(true);
-});
-
-test("polymarket resolution reloads the event and follows a rotated YES token", async () => {
-  const requested: string[] = [];
-  setHttpFetchTransport(async (url) => {
-    requested.push(url);
-    if (url.endsWith("/events/event-1")) {
-      return json({
-        id: "event-1",
-        title: "Current event",
-        markets: [{
-          id: "market-1",
-          question: "Current market title",
-          active: true,
-          closed: false,
-          outcomes: ["Yes", "No"],
-          outcomePrices: ["0.7", "0.3"],
-          clobTokenIds: ["rotated-yes", "rotated-no"],
-        }],
-      });
-    }
-    if (url.includes("prices-history")) return json({ history: [{ t: 1_700_000_000, p: 0.7 }] });
-    throw new Error(`Unexpected URL ${url}`);
-  });
-
-  const resolved = await predictionChartSeriesCapability.provider.resolve({
-    seriesId: "polymarket/event-1/market-1",
-    viewport: { range: "1M", resolution: "auto" },
-  });
-
-  expect(resolved.label).toBe("Current market title");
-  expect(resolved.points[0]?.value).toBe(0.7);
-  expect(requested.some((url) => url.includes("market=rotated-yes"))).toBe(true);
-});
-
-test("polymarket pans request and cache their bounded history windows", async () => {
-  attachPredictionMarketsPersistence(new MemoryPersistence());
-  const historyRequests: string[] = [];
-  setHttpFetchTransport(async (url) => {
-    if (url.endsWith("/events/event-1")) {
-      return json({
-        id: "event-1",
-        title: "Current event",
-        markets: [{
-          id: "market-1",
-          question: "Current market title",
-          active: true,
-          closed: false,
-          outcomes: ["Yes", "No"],
-          outcomePrices: ["0.7", "0.3"],
-          clobTokenIds: ["yes-token", "no-token"],
-        }],
-      });
-    }
-    if (url.includes("prices-history")) {
-      historyRequests.push(url);
-      const start = Number(new URL(url).searchParams.get("startTs"));
-      return json({ history: [{ t: start + 1, p: 0.7 }] });
-    }
-    throw new Error(`Unexpected URL ${url}`);
-  });
-  const viewport = (start: string, end: string) => ({
-    range: "1W" as const,
-    resolution: "auto" as const,
-    dateWindow: { start, end },
-  });
-  const january = viewport("2026-01-01T00:00:00.000Z", "2026-01-08T00:00:00.000Z");
-  const february = viewport("2026-02-01T00:00:00.000Z", "2026-02-08T00:00:00.000Z");
-
-  await predictionChartSeriesCapability.provider.resolve({
-    seriesId: "polymarket/event-1/market-1",
-    viewport: january,
-  });
-  const panned = await predictionChartSeriesCapability.provider.resolve({
-    seriesId: "polymarket/event-1/market-1",
-    viewport: february,
-  });
-  await predictionChartSeriesCapability.provider.resolve({
-    seriesId: "polymarket/event-1/market-1",
-    viewport: january,
-  });
-
-  expect(historyRequests).toHaveLength(2);
-  expect(historyRequests.map((url) => {
-    const params = new URL(url).searchParams;
-    return [params.get("startTs"), params.get("endTs"), params.get("interval")];
-  })).toEqual([
-    [String(Date.parse(january.dateWindow.start) / 1000), String(Date.parse(january.dateWindow.end) / 1000), null],
-    [String(Date.parse(february.dateWindow.start) / 1000), String(Date.parse(february.dateWindow.end) / 1000), null],
-  ]);
-  expect(panned.points[0]?.date.toISOString()).toBe("2026-02-01T00:00:01.000Z");
-});
-
-test("aborting catalog search stops Polymarket event hydration without caching it", async () => {
-  attachPredictionMarketsPersistence(new MemoryPersistence());
-  let searchRequests = 0;
-  let eventRequests = 0;
-  let markHydrationStarted: (() => void) | undefined;
-  const hydrationStarted = new Promise<void>((resolve) => {
-    markHydrationStarted = resolve;
-  });
-  setHttpFetchTransport(async (url, init) => {
-    if (url.includes("public-search")) {
-      searchRequests += 1;
-      return json({ events: [{ id: "event-1" }] });
-    }
-    if (url.endsWith("/events/event-1")) {
-      eventRequests += 1;
-      if (eventRequests === 1) {
-        markHydrationStarted?.();
-        return await new Promise<Response>((_resolve, reject) => {
-          init?.signal?.addEventListener("abort", () => reject(init.signal?.reason), { once: true });
-        });
-      }
-      return json({
-        id: "event-1",
-        title: "Rates",
-        markets: [{
-          id: "market-1",
-          question: "Rates",
-          active: true,
-          closed: false,
-          outcomes: ["Yes", "No"],
-          outcomePrices: ["0.5", "0.5"],
-          clobTokenIds: ["yes", "no"],
-        }],
-      });
-    }
-    if (url.includes("api.elections.kalshi.com")) return json({ events: [] });
-    throw new Error(`Unexpected URL ${url}`);
-  });
-
-  const controller = new AbortController();
-  const pending = predictionChartSeriesCapability.provider.search!({
-    query: "rates",
-    limit: 1,
-    signal: controller.signal,
-  });
-  await hydrationStarted;
-  controller.abort();
-  await expect(pending).rejects.toMatchObject({ name: "AbortError" });
-
-  const retried = await predictionChartSeriesCapability.provider.search!({ query: "rates", limit: 1 });
-  expect(retried).toHaveLength(1);
-  expect(searchRequests).toBe(2);
-  expect(eventRequests).toBe(2);
-});
-
-test("kalshi resolution reloads the event before requesting current market history", async () => {
-  const requested: string[] = [];
-  setHttpFetchTransport(async (url) => {
-    requested.push(url);
-    if (url.endsWith("/events/EVT-1")) {
-      return json({
-        event: { title: "Current event", event_ticker: "EVT-1", series_ticker: "SERIES-NEW" },
-        markets: [{
-          ticker: "MKT-1",
-          event_ticker: "EVT-1",
-          title: "Current Kalshi market",
-          status: "active",
-          market_type: "binary",
-          last_price_dollars: "0.55",
-        }],
-      });
-    }
-    if (url.includes("/candlesticks")) {
-      return json({ candlesticks: [{ end_period_ts: 1_700_000_000, price: { close_dollars: "0.55" } }] });
-    }
-    throw new Error(`Unexpected URL ${url}`);
-  });
-
-  const resolved = await predictionChartSeriesCapability.provider.resolve({
-    seriesId: "kalshi/EVT-1/MKT-1",
-    viewport: {
-      range: "1W",
-      resolution: "auto",
-      dateWindow: { start: "2026-01-01T00:00:00.000Z", end: "2026-01-08T00:00:00.000Z" },
-    },
-  });
-
-  expect(resolved.label).toBe("Current Kalshi market");
-  expect(requested.some((url) => url.includes("/series/SERIES-NEW/markets/MKT-1/candlesticks"))).toBe(true);
-  expect(requested.some((url) => url.includes("start_ts=1767225600") && url.includes("end_ts=1767830400"))).toBe(true);
-});
-
-test("resolution reports an actionable error when a persisted market disappears", async () => {
-  setHttpFetchTransport(async () => json({ id: "event-1", title: "Current event", markets: [] }));
-
-  await expect(predictionChartSeriesCapability.provider.resolve({
-    seriesId: "polymarket/event-1/missing",
-    viewport: { range: "1M", resolution: "auto" },
-  })).rejects.toThrow("no longer resolvable. Remove or replace this chart series");
-});

package/src/plugins/prediction-markets/capability.ts

@@ -1,171 +0,0 @@
-import { chartSeriesProvider, type ChartSeriesCatalogItem, type ChartSeriesResolveRequest } from "../../capabilities";
-import { debugLog } from "../../utils/debug-log";
-import type { ResolvedSeries, TimeSeriesPoint } from "../../time-series/types";
-import {
-  loadKalshiCatalog,
-  loadKalshiHistory,
-  resolveKalshiChartSummary,
-} from "./services/kalshi/adapter";
-import { loadPolymarketCatalog } from "./services/polymarket/adapter";
-import {
-  loadPolymarketHistory,
-  resolvePolymarketChartSummary,
-} from "./services/polymarket/detail";
-import type { PredictionHistoryPoint, PredictionHistoryRange, PredictionMarketSummary, PredictionVenue } from "./types";
-
-export const PREDICTION_CHART_SERIES_CAPABILITY_ID = "prediction-markets.series";
-const predictionSeriesLog = debugLog.createLogger("prediction-markets.series");
-
-interface PredictionSeriesIdentity {
-  venue: PredictionVenue;
-  eventId: string;
-  marketId: string;
-}
-
-export function predictionSeriesId(summary: PredictionMarketSummary): string | null {
-  const eventId = summary.venue === "kalshi" ? summary.eventTicker : summary.eventId;
-  if (!eventId?.trim() || !summary.marketId.trim()) return null;
-  const id = `${summary.venue}/${encodeURIComponent(eventId)}/${encodeURIComponent(summary.marketId)}`;
-  return id.length <= 240 ? id : null;
-}
-
-function parsePredictionSeriesId(seriesId: string): PredictionSeriesIdentity {
-  const parts = seriesId.split("/");
-  if (parts.length !== 3 || (parts[0] !== "kalshi" && parts[0] !== "polymarket")) {
-    throw new Error(`Prediction series ID ${seriesId} is invalid. Remove and add the series again.`);
-  }
-  try {
-    const eventId = decodeURIComponent(parts[1] ?? "");
-    const marketId = decodeURIComponent(parts[2] ?? "");
-    if (!eventId || !marketId) throw new Error("missing identity");
-    return { venue: parts[0], eventId, marketId };
-  } catch {
-    throw new Error(`Prediction series ID ${seriesId} is invalid. Remove and add the series again.`);
-  }
-}
-
-function historyRange(request: ChartSeriesResolveRequest): PredictionHistoryRange {
-  if (request.viewport.dateWindow) {
-    const span = Date.parse(request.viewport.dateWindow.end) - Date.parse(request.viewport.dateWindow.start);
-    if (span <= 24 * 60 * 60_000) return "1D";
-    if (span <= 7 * 24 * 60 * 60_000) return "1W";
-    if (span <= 31 * 24 * 60 * 60_000) return "1M";
-    return "ALL";
-  }
-  switch (request.viewport.range) {
-    case "1D": return "1D";
-    case "1W": return "1W";
-    case "1M": return "1M";
-    default: return "ALL";
-  }
-}
-
-export function predictionHistoryPoints(points: PredictionHistoryPoint[], venue: string): TimeSeriesPoint[] {
-  return points.flatMap((point) => {
-    const date = point.date instanceof Date ? new Date(point.date) : new Date(point.date as unknown as string);
-    if (!Number.isFinite(date.getTime()) || !Number.isFinite(point.close)) return [];
-    return [{
-      date,
-      observedAt: new Date(date),
-      value: point.close,
-      open: point.open,
-      high: point.high,
-      low: point.low,
-      close: point.close,
-      volume: point.volume,
-      provenance: { providerId: venue, quality: "reported" as const },
-    }];
-  }).sort((left, right) => left.date.getTime() - right.date.getTime());
-}
-
-function catalogItem(summary: PredictionMarketSummary): ChartSeriesCatalogItem | null {
-  const seriesId = predictionSeriesId(summary);
-  if (!seriesId) return null;
-  return {
-    seriesId,
-    label: summary.title.slice(0, 160),
-    description: `${summary.venue === "kalshi" ? "Kalshi" : "Polymarket"} · YES probability`,
-    detail: summary.venue === "kalshi" ? "Kalshi" : "Polymarket",
-    style: "area",
-  };
-}
-
-async function catalog(
-  query = "",
-  limit = 8,
-  signal?: AbortSignal,
-): Promise<ChartSeriesCatalogItem[]> {
-  const providers = [
-    { id: "polymarket", load: () => loadPolymarketCatalog(query, "all", { limit, signal }) },
-    { id: "kalshi", load: () => loadKalshiCatalog(query, "all", { limit, signal }) },
-  ] as const;
-  const results = await Promise.allSettled(providers.map((provider) => provider.load()));
-  if (signal?.aborted) throw signal.reason ?? new DOMException("Aborted", "AbortError");
-  const failures = results.flatMap((result, index) => {
-    if (result.status === "fulfilled") return [];
-    const error = result.reason instanceof Error ? result.reason.message : String(result.reason);
-    predictionSeriesLog.warn("Prediction chart catalog provider failed", {
-      provider: providers[index]?.id,
-      error,
-    });
-    return [`${providers[index]?.id}: ${error}`];
-  });
-  if (failures.length === providers.length) {
-    throw new Error(`Prediction chart catalog failed (${failures.join("; ")}).`);
-  }
-  return results
-    .flatMap((result) => result.status === "fulfilled" ? result.value : [])
-    .sort((left, right) => (right.volume24h ?? 0) - (left.volume24h ?? 0))
-    .flatMap((summary) => {
-      const item = catalogItem(summary);
-      return item ? [item] : [];
-    })
-    .slice(0, limit);
-}
-
-async function resolveCurrentSummary(identity: PredictionSeriesIdentity, signal?: AbortSignal) {
-  return identity.venue === "kalshi"
-    ? resolveKalshiChartSummary(identity.eventId, identity.marketId, signal)
-    : resolvePolymarketChartSummary(identity.eventId, identity.marketId, signal);
-}
-
-export const predictionChartSeriesCapability = chartSeriesProvider({
-  id: PREDICTION_CHART_SERIES_CAPABILITY_ID,
-  name: "Prediction Markets",
-  provider: {
-    catalog: (request) => catalog(request.query, request.limit, request.signal),
-    search: (request) => catalog(request.query, request.limit, request.signal),
-    async resolve(request): Promise<ResolvedSeries> {
-      const identity = parsePredictionSeriesId(request.seriesId);
-      const summary = await resolveCurrentSummary(identity, request.signal);
-      const range = historyRange(request);
-      const dateWindow = request.viewport.dateWindow;
-      const historyOptions = {
-        ...(dateWindow ? {
-          start: new Date(dateWindow.start),
-          end: new Date(dateWindow.end),
-        } : {}),
-        signal: request.signal,
-        strict: true,
-      };
-      const history = summary.venue === "kalshi"
-        ? await loadKalshiHistory(summary, range, historyOptions)
-        : await loadPolymarketHistory(summary, range, historyOptions);
-      return {
-        id: request.seriesId,
-        label: summary.title.slice(0, 160),
-        color: "#4dabf7",
-        unit: "probability",
-        unitGroup: "probability",
-        nativeFrequency: "auto",
-        dataShape: "scalar",
-        style: "area",
-        transform: "raw",
-        axis: "left",
-        panelId: "main",
-        interpolation: "none",
-        points: predictionHistoryPoints(history, summary.venue),
-      };
-    },
-  },
-});

package/src/plugins/prediction-markets/categories.ts

@@ -1,213 +0,0 @@
-import type { PredictionListRow, PredictionMarketSummary } from "./types";
-
-type PredictionCategoryTarget = Pick<
-  PredictionMarketSummary | PredictionListRow,
-  "category" | "tags" | "eventLabel" | "title"
->;
-
-export type PredictionCategoryId =
-  | "all"
-  | "politics"
-  | "world"
-  | "macro"
-  | "crypto"
-  | "science"
-  | "sports"
-  | "entertainment"
-  | "climate"
-  | "social";
-
-export interface PredictionCategoryOption {
-  id: PredictionCategoryId;
-  label: string;
-}
-
-interface PredictionVenueCategoryMap {
-  polymarketTagSlugs: string[];
-  kalshiCategories: string[];
-}
-
-export const PREDICTION_CATEGORY_OPTIONS: PredictionCategoryOption[] = [
-  { id: "all", label: "All" },
-  { id: "politics", label: "Politics" },
-  { id: "world", label: "World" },
-  { id: "macro", label: "Macro" },
-  { id: "crypto", label: "Crypto" },
-  { id: "science", label: "Science" },
-  { id: "sports", label: "Sports" },
-  { id: "entertainment", label: "Entertainment" },
-  { id: "climate", label: "Climate" },
-  { id: "social", label: "Social" },
-] as const;
-
-const CATEGORY_KEYWORDS: Record<
-  Exclude<PredictionCategoryId, "all">,
-  string[]
-> = {
-  politics: ["politics", "elections"],
-  world: [
-    "world",
-    "geopolitics",
-    "foreign policy",
-    "middle east",
-    "global",
-    "iran",
-    "israel",
-    "gaza",
-    "ukraine",
-    "russia",
-    "china",
-    "taiwan",
-    "war",
-    "conflict",
-    "ceasefire",
-    "military",
-    "strike",
-  ],
-  macro: [
-    "economics",
-    "financials",
-    "companies",
-    "macro",
-    "fed",
-    "inflation",
-    "tariffs",
-    "jobs",
-    "debt",
-  ],
-  crypto: ["crypto", "bitcoin", "ethereum", "solana", "defi", "altcoin"],
-  science: ["science", "technology", "ai"],
-  sports: ["sports"],
-  entertainment: ["entertainment", "movies", "music", "tv", "celebrity"],
-  climate: ["climate", "weather"],
-  social: ["social", "health", "education", "transportation"],
-};
-
-const VENUE_CATEGORY_MAP: Record<
-  Exclude<PredictionCategoryId, "all">,
-  PredictionVenueCategoryMap
-> = {
-  politics: {
-    polymarketTagSlugs: ["politics"],
-    kalshiCategories: ["Politics", "Elections"],
-  },
-  world: {
-    polymarketTagSlugs: [
-      "world",
-      "geopolitics",
-      "iran",
-      "israel",
-      "military-strikes",
-    ],
-    kalshiCategories: ["World", "Politics"],
-  },
-  macro: {
-    polymarketTagSlugs: ["economy", "finance", "business"],
-    kalshiCategories: ["Economics"],
-  },
-  crypto: {
-    polymarketTagSlugs: ["crypto"],
-    kalshiCategories: ["Crypto"],
-  },
-  science: {
-    polymarketTagSlugs: ["science", "technology", "ai"],
-    kalshiCategories: ["Science and Technology"],
-  },
-  sports: {
-    polymarketTagSlugs: ["sports"],
-    kalshiCategories: ["Sports"],
-  },
-  entertainment: {
-    polymarketTagSlugs: ["entertainment", "pop-culture"],
-    kalshiCategories: ["Entertainment"],
-  },
-  climate: {
-    polymarketTagSlugs: ["climate", "weather"],
-    kalshiCategories: ["Climate and Weather"],
-  },
-  social: {
-    polymarketTagSlugs: ["social", "health", "education"],
-    kalshiCategories: ["Social"],
-  },
-};
-
-const DISPLAY_CATEGORY_PRIORITY = [
-  "Geopolitics",
-  "World",
-  "Middle East",
-  "Politics",
-  "Economics",
-  "Financials",
-  "Crypto",
-  "Science and Technology",
-  "Sports",
-  "Entertainment",
-  "Climate and Weather",
-  "Social",
-  "Companies",
-  "Health",
-  "Education",
-  "Transportation",
-] as const;
-
-function normalizeCategoryText(value: string): string {
-  return value.trim().toLowerCase();
-}
-
-export function resolvePredictionDisplayCategory(
-  tags: string[],
-): string | undefined {
-  for (const preferred of DISPLAY_CATEGORY_PRIORITY) {
-    const match = tags.find(
-      (tag) => normalizeCategoryText(tag) === normalizeCategoryText(preferred),
-    );
-    if (match) return match;
-  }
-  return tags[0];
-}
-
-export function matchesPredictionCategory(
-  market: PredictionCategoryTarget,
-  categoryId: PredictionCategoryId,
-): boolean {
-  if (categoryId === "all") return true;
-  const keywords = CATEGORY_KEYWORDS[categoryId];
-  const haystack = [
-    market.category ?? "",
-    ...(market.tags ?? []),
-    market.eventLabel,
-    market.title,
-  ]
-    .join(" ")
-    .toLowerCase();
-  return keywords.some((keyword) => haystack.includes(keyword));
-}
-
-export function getPolymarketCategoryTagSlugs(
-  categoryId: PredictionCategoryId,
-): string[] {
-  if (categoryId === "all") return [];
-  return VENUE_CATEGORY_MAP[categoryId].polymarketTagSlugs;
-}
-
-export function getKalshiCategoryNames(
-  categoryId: PredictionCategoryId,
-): string[] {
-  if (categoryId === "all") return [];
-  return VENUE_CATEGORY_MAP[categoryId].kalshiCategories;
-}
-
-export function getAdjacentPredictionCategoryId(
-  current: PredictionCategoryId,
-  direction: "previous" | "next",
-): PredictionCategoryId {
-  const currentIndex = PREDICTION_CATEGORY_OPTIONS.findIndex(
-    (option) => option.id === current,
-  );
-  const safeIndex = currentIndex >= 0 ? currentIndex : 0;
-  const nextIndex =
-    direction === "previous"
-      ? Math.max(safeIndex - 1, 0)
-      : Math.min(safeIndex + 1, PREDICTION_CATEGORY_OPTIONS.length - 1);
-  return PREDICTION_CATEGORY_OPTIONS[nextIndex]!.id;
-}