horizon-code 0.1.0

package/src/platform/usage.ts

@@ -0,0 +1,224 @@
+// Usage manager — token budgets, rate limiting, subscription tracking
+// Reads from Supabase, enforces limits locally, syncs usage atomically
+
+import { getSupabase, getUser } from "./supabase.ts";
+import {
+  type PlanTier, type ModelPower,
+  TIER_CONFIG, MODEL_MULTIPLIER, getWindowBounds, formatTimeRemaining, resolveModel,
+} from "./tiers.ts";
+
+interface Subscription {
+  plan: PlanTier;
+  status: string;
+  current_period_end: string | null;
+}
+
+export interface UsageState {
+  tier: PlanTier;
+  budget: number;
+  consumed: number;
+  windowEnd: number;
+  overflowing: boolean;   // true when paid user exhausted budget, using fast
+}
+
+export interface RequestCheck {
+  allowed: boolean;
+  reason?: "budget" | "rate_limit" | "not_authenticated";
+  modelId: string;
+  effectivePower: ModelPower;
+  downgraded: boolean;
+  message?: string;
+  timeUntilRefresh?: string;
+}
+
+class UsageManager {
+  private _sub: Subscription = { plan: "free", status: "active", current_period_end: null };
+  private _windowConsumed = 0;
+  private _windowEnd = 0;
+  private _windowStart = new Date();
+  private _lastSubFetch = 0;
+  private _initialized = false;
+
+  get tier(): PlanTier { return this._sub.plan; }
+  get state(): UsageState {
+    const config = TIER_CONFIG[this._sub.plan];
+    return {
+      tier: this._sub.plan,
+      budget: config.tokenBudget,
+      consumed: this._windowConsumed,
+      windowEnd: this._windowEnd,
+      overflowing: this._windowConsumed >= config.tokenBudget && config.overflowToFast,
+    };
+  }
+
+  async initialize(): Promise<void> {
+    await this.refreshSubscription();
+    await this.refreshWindowUsage();
+    this._initialized = true;
+  }
+
+  // ── Subscription ──
+
+  async refreshSubscription(): Promise<void> {
+    const sb = getSupabase();
+    const user = getUser();
+    if (!user) { this._sub = { plan: "free", status: "active", current_period_end: null }; return; }
+
+    try {
+      const { data } = await sb.from("subscriptions")
+        .select("plan, status, current_period_end")
+        .eq("user_id", user.id)
+        .single();
+
+      if (data) {
+        // Past due or canceled = treat as free
+        const plan = (data.status === "active" ? data.plan : "free") as PlanTier;
+        this._sub = { plan, status: data.status, current_period_end: data.current_period_end };
+      } else {
+        this._sub = { plan: "free", status: "active", current_period_end: null };
+      }
+    } catch {
+      // Supabase unreachable — keep current tier
+    }
+    this._lastSubFetch = Date.now();
+  }
+
+  // ── Window usage ──
+
+  async refreshWindowUsage(): Promise<void> {
+    const sb = getSupabase();
+    const user = getUser();
+    if (!user) return;
+
+    const { start, end } = getWindowBounds();
+    this._windowStart = start;
+    this._windowEnd = end.getTime();
+
+    try {
+      const { data } = await sb.from("token_usage_windows")
+        .select("tokens_used")
+        .eq("user_id", user.id)
+        .eq("window_start", start.toISOString())
+        .single();
+
+      this._windowConsumed = data?.tokens_used ?? 0;
+    } catch {
+      // No row = 0 usage, or Supabase unreachable
+    }
+  }
+
+  // ── Pre-check: can the user make a request? ──
+
+  async canMakeRequest(power: ModelPower): Promise<RequestCheck> {
+    const user = getUser();
+    if (!user) {
+      return { allowed: false, reason: "not_authenticated", modelId: "", effectivePower: "fast", downgraded: false, message: "Not authenticated. Type /login." };
+    }
+
+    // Refresh subscription every 60s
+    if (Date.now() - this._lastSubFetch > 60_000) {
+      await this.refreshSubscription();
+    }
+
+    // Refresh window usage (cross-device sync)
+    await this.refreshWindowUsage();
+
+    const config = TIER_CONFIG[this._sub.plan];
+    const budgetExhausted = this._windowConsumed >= config.tokenBudget;
+    const timeLeft = formatTimeRemaining(this._windowEnd - Date.now());
+
+    // Resolve model (may downgrade)
+    const { modelId, effectivePower, downgraded } = resolveModel(this._sub.plan, power, budgetExhausted);
+
+    // Budget exhausted
+    if (budgetExhausted && !config.overflowToFast) {
+      // Free user: blocked
+      return {
+        allowed: false, reason: "budget", modelId, effectivePower, downgraded,
+        message: `Budget exhausted. Free plan: ${(config.tokenBudget / 1000).toFixed(0)}K tokens/window. Refreshes in ${timeLeft}.\nUpgrade at https://mathematicalcompany.com/pricing`,
+        timeUntilRefresh: timeLeft,
+      };
+    }
+
+    // Rate limit check
+    try {
+      const sb = getSupabase();
+      // Insert rate limit entry
+      await sb.from("rate_limit_log").insert({ user_id: user.id });
+      // Check count
+      const { data } = await sb.rpc("check_rate_limit", { p_user_id: user.id });
+      const count = typeof data === "number" ? data : 0;
+      if (count > config.ratePerMinute) {
+        return {
+          allowed: false, reason: "rate_limit", modelId, effectivePower, downgraded,
+          message: `Slow down. ${this._sub.plan} plan: ${config.ratePerMinute} requests/min. Try again in a few seconds.`,
+        };
+      }
+    } catch {
+      // Rate limit check failed — allow (fail open)
+    }
+
+    let message: string | undefined;
+    if (budgetExhausted && config.overflowToFast) {
+      message = `Budget used. Switched to Fast mode until refresh in ${timeLeft}.`;
+    } else if (downgraded) {
+      const tierLabel = this._sub.plan.charAt(0).toUpperCase() + this._sub.plan.slice(1);
+      message = `${power} model requires ${power === "ultra" ? "Ultra" : "Pro"} plan. Using ${effectivePower} instead.`;
+    }
+
+    return { allowed: true, modelId, effectivePower, downgraded, message };
+  }
+
+  // ── Post-call: record usage ──
+
+  async recordUsage(opts: {
+    rawInput: number;
+    rawOutput: number;
+    effectivePower: ModelPower;
+    model: string;
+  }): Promise<void> {
+    const user = getUser();
+    if (!user) return;
+
+    const rawTotal = opts.rawInput + opts.rawOutput;
+    const multiplier = MODEL_MULTIPLIER[opts.effectivePower];
+    const weighted = Math.round(rawTotal * multiplier);
+
+    const { start, end } = getWindowBounds();
+
+    try {
+      const sb = getSupabase();
+      const { data } = await sb.rpc("increment_token_usage", {
+        p_user_id: user.id,
+        p_window_start: start.toISOString(),
+        p_window_end: end.toISOString(),
+        p_weighted_tokens: weighted,
+        p_raw_input: opts.rawInput,
+        p_raw_output: opts.rawOutput,
+        p_model: opts.model,
+      });
+
+      if (typeof data === "number") {
+        this._windowConsumed = data;
+      } else {
+        this._windowConsumed += weighted;
+      }
+    } catch {
+      // Offline: track locally
+      this._windowConsumed += weighted;
+    }
+  }
+
+  // ── Helpers ──
+
+  budgetPct(): number {
+    const budget = TIER_CONFIG[this._sub.plan].tokenBudget;
+    return budget > 0 ? Math.min(1, this._windowConsumed / budget) : 0;
+  }
+
+  budgetRemaining(): number {
+    return Math.max(0, TIER_CONFIG[this._sub.plan].tokenBudget - this._windowConsumed);
+  }
+}
+
+export const usageManager = new UsageManager();

package/src/research/apis.ts

@@ -0,0 +1,367 @@
+// External API clients — Polymarket, Kalshi, Exa, Cala
+
+const GAMMA = "https://gamma-api.polymarket.com";
+const CLOB = "https://clob.polymarket.com";
+const KALSHI = "https://api.elections.kalshi.com/trade-api/v2";
+const DATA_API = "https://data-api.polymarket.com";
+// EXA and CALA now proxied through API server — keys held server-side
+
+async function get(url: string): Promise<any> {
+  const res = await fetch(url, { signal: AbortSignal.timeout(10000) });
+  if (!res.ok) throw new Error(`${res.status} ${url}`);
+  return res.json();
+}
+
+async function post(url: string, body: any, headers: Record<string, string> = {}): Promise<any> {
+  const res = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", ...headers },
+    body: JSON.stringify(body),
+    signal: AbortSignal.timeout(10000),
+  });
+  if (!res.ok) throw new Error(`${res.status} ${url}`);
+  return res.json();
+}
+
+// ── Polymarket (Gamma API — public, no auth) ──
+
+// Gamma API has NO text search — tag param matches predefined categories, not free text.
+// Strategy: always fetch a large batch sorted by volume, filter client-side on title + description.
+// We cache the batch for 60 seconds to avoid hammering the API on repeated searches.
+
+let _eventsCache: { data: any[]; ts: number } = { data: [], ts: 0 };
+const CACHE_TTL = 60_000; // 60 seconds
+
+async function fetchAllEvents(): Promise<any[]> {
+  if (_eventsCache.data.length > 0 && Date.now() - _eventsCache.ts < CACHE_TTL) {
+    return _eventsCache.data;
+  }
+  const params = new URLSearchParams({
+    active: "true", closed: "false",
+    order: "volume24hr", ascending: "false",
+    limit: "200",
+  });
+  const data = await get(`${GAMMA}/events?${params}`).catch(() => []);
+  _eventsCache = { data: data ?? [], ts: Date.now() };
+  return _eventsCache.data;
+}
+
+export async function gammaEvents(opts: { query?: string; limit?: number } = {}): Promise<any[]> {
+  const limit = Math.min(opts.limit ?? 10, 20);
+  const query = (opts.query ?? "").toLowerCase().trim();
+
+  const allEvents = await fetchAllEvents();
+
+  let data: any[];
+
+  if (!query) {
+    // No query: return top by volume
+    data = allEvents.slice(0, limit);
+  } else {
+    // Split query into words for flexible matching
+    const words = query.split(/\s+/).filter((w) => w.length > 1);
+
+    // First pass: ALL words must match (strict)
+    data = allEvents.filter((e: any) => {
+      const text = ((e.title ?? "") + " " + (e.description ?? "") + " " +
+        (e.tags ?? []).map((t: any) => t.label ?? t).join(" ")).toLowerCase();
+      return words.every((w) => text.includes(w));
+    });
+
+    // Second pass: ANY word matches (broader)
+    if (data.length === 0 && words.length > 1) {
+      data = allEvents.filter((e: any) => {
+        const text = ((e.title ?? "") + " " + (e.description ?? "") + " " +
+          (e.tags ?? []).map((t: any) => t.label ?? t).join(" ")).toLowerCase();
+        return words.some((w) => text.includes(w));
+      });
+    }
+
+    // Sort matches by relevance: title match > description match, then by volume
+    data.sort((a: any, b: any) => {
+      const aTitle = (a.title ?? "").toLowerCase();
+      const bTitle = (b.title ?? "").toLowerCase();
+      const aInTitle = words.some((w) => aTitle.includes(w)) ? 1 : 0;
+      const bInTitle = words.some((w) => bTitle.includes(w)) ? 1 : 0;
+      if (aInTitle !== bInTitle) return bInTitle - aInTitle;
+      return (b.volume24hr ?? 0) - (a.volume24hr ?? 0);
+    });
+
+    data = data.slice(0, limit);
+  }
+
+  return (data ?? []).map((e: any) => ({
+    title: e.title, slug: e.slug, eventId: e.id,
+    description: (e.description ?? "").slice(0, 500),
+    volume: e.volume, liquidity: e.liquidity,
+    volume24hr: e.volume24hr, openInterest: e.openInterest,
+    startDate: e.startDate, endDate: e.endDate,
+    tags: (e.tags ?? []).map((t: any) => t.label ?? t),
+    oneDayPriceChange: e.oneDayPriceChange,
+    url: `https://polymarket.com/event/${e.slug}`,
+    markets: (e.markets ?? []).map((m: any) => ({
+      question: m.question, conditionId: m.conditionId,
+      yesPrice: m.outcomePrices ? JSON.parse(m.outcomePrices)[0] : null,
+      noPrice: m.outcomePrices ? JSON.parse(m.outcomePrices)[1] : null,
+      volume: m.volume, liquidity: m.liquidity,
+      bestBid: m.bestBid, bestAsk: m.bestAsk, lastPrice: m.lastTradePrice,
+      oneDayPriceChange: m.oneDayPriceChange,
+    })),
+  }));
+}
+
+export async function gammaEventDetail(slug: string): Promise<any> {
+  const events = await get(`${GAMMA}/events?slug=${slug}`);
+  const event = events?.[0];
+  if (!event) throw new Error(`Event not found: ${slug}`);
+
+  // Fetch price history for first market
+  let priceHistory: any[] = [];
+  const firstMarket = event.markets?.[0];
+  if (firstMarket) {
+    const tokenId = firstMarket.clobTokenIds ? JSON.parse(firstMarket.clobTokenIds)[0] : null;
+    if (tokenId) {
+      try {
+        const hist = await get(`${CLOB}/prices-history?market=${tokenId}&interval=max&fidelity=60`);
+        priceHistory = hist?.history ?? [];
+      } catch {}
+    }
+  }
+
+  return {
+    title: event.title, slug: event.slug,
+    description: (event.description ?? "").slice(0, 1000),
+    volume: event.volume, liquidity: event.liquidity,
+    volume24hr: event.volume24hr, endDate: event.endDate,
+    tags: (event.tags ?? []).map((t: any) => t.label ?? t),
+    url: `https://polymarket.com/event/${event.slug}`,
+    priceHistory,
+    markets: (event.markets ?? []).map((m: any) => ({
+      question: m.question, conditionId: m.conditionId,
+      yesPrice: m.outcomePrices ? JSON.parse(m.outcomePrices)[0] : null,
+      noPrice: m.outcomePrices ? JSON.parse(m.outcomePrices)[1] : null,
+      volume: m.volume, liquidity: m.liquidity,
+      bestBid: m.bestBid, bestAsk: m.bestAsk,
+      spread: m.bestAsk && m.bestBid ? +(m.bestAsk - m.bestBid).toFixed(4) : null,
+      lastPrice: m.lastTradePrice,
+    })),
+  };
+}
+
+export async function clobPriceHistory(slug: string, interval = "1w", fidelity = 60): Promise<any> {
+  const events = await get(`${GAMMA}/events?slug=${slug}`);
+  const market = events?.[0]?.markets?.[0];
+  if (!market) throw new Error(`Market not found: ${slug}`);
+
+  const tokenId = market.clobTokenIds ? JSON.parse(market.clobTokenIds)[0] : null;
+  if (!tokenId) throw new Error("No token ID");
+
+  const hist = await get(`${CLOB}/prices-history?market=${tokenId}&interval=${interval}&fidelity=${fidelity}`);
+  const points = hist?.history ?? [];
+  const prices = points.map((p: any) => p.p);
+
+  return {
+    title: events[0].title, slug,
+    url: `https://polymarket.com/event/${slug}`,
+    marketQuestion: market.question,
+    interval, dataPoints: points.length,
+    current: prices.length > 0 ? prices[prices.length - 1] : null,
+    high: prices.length > 0 ? Math.max(...prices) : null,
+    low: prices.length > 0 ? Math.min(...prices) : null,
+    change: prices.length > 1 ? +((prices[prices.length - 1] - prices[0]) / prices[0]).toFixed(4) : null,
+    priceHistory: points,
+  };
+}
+
+export async function clobOrderBook(slug: string, marketIndex = 0, outcomeIndex = 0): Promise<any> {
+  const events = await get(`${GAMMA}/events?slug=${slug}`);
+  const market = events?.[0]?.markets?.[marketIndex];
+  if (!market) throw new Error(`Market not found: ${slug}`);
+
+  const tokenId = market.clobTokenIds ? JSON.parse(market.clobTokenIds)[outcomeIndex] : null;
+  if (!tokenId) throw new Error("No token ID");
+
+  const book = await get(`${CLOB}/book?token_id=${tokenId}`);
+
+  return {
+    title: events[0].title, slug,
+    url: `https://polymarket.com/event/${slug}`,
+    marketQuestion: market.question,
+    outcome: outcomeIndex === 0 ? "Yes" : "No",
+    bestBid: book?.bids?.[0]?.price ?? null,
+    bestAsk: book?.asks?.[0]?.price ?? null,
+    spread: book?.bids?.[0] && book?.asks?.[0]
+      ? +(book.asks[0].price - book.bids[0].price).toFixed(4) : null,
+    bids: (book?.bids ?? []).slice(0, 15).map((l: any) => ({ price: +l.price, size: +l.size })),
+    asks: (book?.asks ?? []).slice(0, 15).map((l: any) => ({ price: +l.price, size: +l.size })),
+  };
+}
+
+export async function polymarketTrades(slug: string): Promise<any> {
+  const events = await get(`${GAMMA}/events?slug=${slug}`);
+  const market = events?.[0]?.markets?.[0];
+  if (!market) throw new Error(`Market not found: ${slug}`);
+
+  const [trades, holders] = await Promise.all([
+    get(`${DATA_API}/trades?market=${market.conditionId}&limit=20`).catch(() => []),
+    get(`${DATA_API}/holders?market=${market.conditionId}&limit=10`).catch(() => []),
+  ]);
+
+  const largeTrades = (trades ?? []).filter((t: any) => (t.size ?? 0) >= 500).slice(0, 10);
+  const buyVol = largeTrades.filter((t: any) => t.side === "BUY").reduce((s: number, t: any) => s + (t.size ?? 0), 0);
+  const sellVol = largeTrades.filter((t: any) => t.side === "SELL").reduce((s: number, t: any) => s + (t.size ?? 0), 0);
+
+  return {
+    title: events[0].title, slug,
+    url: `https://polymarket.com/event/${slug}`,
+    largeTrades: largeTrades.map((t: any) => ({
+      side: t.side ?? "UNKNOWN", name: t.maker_name ?? "Anonymous",
+      size: t.size, price: t.price, timestamp: t.created_at,
+    })),
+    topHolders: (holders ?? []).slice(0, 8).map((h: any) => ({
+      name: h.name ?? "Anonymous", amount: h.amount, side: h.side ?? "YES",
+    })),
+    flow: {
+      buyVolume: +buyVol.toFixed(2), sellVolume: +sellVol.toFixed(2),
+      netFlow: +(buyVol - sellVol).toFixed(2),
+      direction: buyVol >= sellVol ? "inflow" : "outflow",
+    },
+  };
+}
+
+// ── Kalshi ──
+
+export async function kalshiEvents(opts: { query?: string; limit?: number } = {}): Promise<any[]> {
+  const params = new URLSearchParams({
+    status: "open", with_nested_markets: "true",
+    limit: String(Math.min(opts.limit ?? 10, 20)),
+  });
+  if (opts.query) params.set("series_ticker", opts.query);
+
+  const data = await get(`${KALSHI}/events?${params}`);
+  return (data?.events ?? []).map((e: any) => ({
+    ticker: e.event_ticker, title: e.title,
+    category: e.category, subtitle: e.sub_title,
+    url: `https://kalshi.com/markets/${e.event_ticker?.toLowerCase()}`,
+    markets: (e.markets ?? []).map((m: any) => ({
+      name: m.title ?? m.subtitle, yesBid: m.yes_bid, yesAsk: m.yes_ask,
+      lastPrice: m.last_price, volume: m.volume,
+      openInterest: m.open_interest, closeTime: m.close_time,
+    })),
+  }));
+}
+
+// ── Exa (web search + sentiment) — via server proxy ──
+
+import { getAuthUrl, loadConfig } from "../platform/config.ts";
+
+async function searchProxy(provider: "exa" | "cala", action: string, query: string, numResults?: number): Promise<any> {
+  const config = loadConfig();
+  if (!config.api_key) return { error: "Not authenticated" };
+
+  try {
+    const res = await fetch(`${getAuthUrl()}/api/v1/search`, {
+      method: "POST",
+      headers: { "Authorization": `Bearer ${config.api_key}`, "Content-Type": "application/json" },
+      body: JSON.stringify({ provider, action, query, numResults }),
+      signal: AbortSignal.timeout(15000),
+    });
+
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({})) as any;
+      return { error: err.error ?? `Search failed (${res.status})` };
+    }
+
+    return res.json();
+  } catch (e: any) {
+    if (e?.name === "TimeoutError" || e?.name === "AbortError") {
+      return { error: `${provider} search timed out` };
+    }
+    return { error: `${provider} search failed: ${e?.message ?? "network error"}` };
+  }
+}
+
+export async function exaSearch(query: string, numResults = 6): Promise<any[]> {
+  const data = await searchProxy("exa", "search", query, numResults);
+  if (data.error) return [{ title: data.error, snippet: "" }];
+  return data.results ?? [];
+}
+
+export async function exaSentiment(slug: string): Promise<any> {
+  const event = await gammaEventDetail(slug);
+  const articles = await exaSearch(`"${event.title}" latest news analysis`, 8);
+
+  const bullish = ["positive", "bullish", "surge", "rally", "gain", "rise", "up", "growth", "boost", "strong"];
+  const bearish = ["negative", "bearish", "drop", "crash", "fall", "down", "loss", "weak", "decline", "risk"];
+
+  let bull = 0, bear = 0;
+  for (const a of articles) {
+    const text = ((a.title ?? "") + " " + (a.snippet ?? "")).toLowerCase();
+    for (const w of bullish) if (text.includes(w)) bull++;
+    for (const w of bearish) if (text.includes(w)) bear++;
+  }
+
+  const total = bull + bear || 1;
+  const score = +((bull - bear) / total).toFixed(2);
+  const label = score >= 0.3 ? "Bullish" : score >= 0.1 ? "Slightly Bullish"
+    : score <= -0.3 ? "Bearish" : score <= -0.1 ? "Slightly Bearish" : "Neutral";
+
+  return {
+    title: event.title, slug, url: event.url,
+    sentiment: { score, label, articleCount: articles.length, bullishSignals: bull, bearishSignals: bear },
+    articles: articles.map((a: any) => ({ title: a.title, url: a.url, snippet: (a.snippet ?? "").slice(0, 200) })),
+  };
+}
+
+// ── Cala — via server proxy (Pro/Ultra only) ──
+
+export async function calaSearch(query: string): Promise<any> {
+  const data = await searchProxy("cala", "search", query);
+  if (data.error) return { content: data.error, sources: [], entities: [] };
+  return data;
+}
+
+// ── Calculators (local, no API needed) ──
+
+export function evCalculator(opts: {
+  marketPrice: number; side: "yes" | "no";
+  estimatedEdge: number; bankroll: number;
+}): any {
+  const { marketPrice, side, estimatedEdge, bankroll } = opts;
+  const price = side === "yes" ? marketPrice : 1 - marketPrice;
+  const trueProb = Math.min(0.99, Math.max(0.01, price + estimatedEdge));
+  const edge = +(trueProb - price).toFixed(4);
+  const winPayout = 1 - price;
+  const ev = +(trueProb * winPayout - (1 - trueProb) * price).toFixed(4);
+  const evPerDollar = +(ev / price).toFixed(4);
+  const b = winPayout / price;
+  const kelly = Math.max(0, +((b * trueProb - (1 - trueProb)) / b).toFixed(4));
+
+  return {
+    side, marketPrice: +price.toFixed(4), trueProb: +trueProb.toFixed(4),
+    edge, ev, evPerDollar,
+    kellyFraction: kelly,
+    positionSizing: {
+      fullKelly: { fraction: kelly, amount: +(bankroll * kelly).toFixed(2) },
+      halfKelly: { fraction: +(kelly / 2).toFixed(4), amount: +(bankroll * kelly / 2).toFixed(2) },
+      quarterKelly: { fraction: +(kelly / 4).toFixed(4), amount: +(bankroll * kelly / 4).toFixed(2) },
+    },
+    riskMetrics: {
+      maxLoss: +price.toFixed(4), maxProfit: +winPayout.toFixed(4),
+      riskReward: +(winPayout / price).toFixed(2),
+      breakevenProb: +price.toFixed(4),
+    },
+    bankroll,
+  };
+}
+
+export function probabilityCalc(pA: number, pB: number): any {
+  const joint = +(pA * pB).toFixed(4);
+  return {
+    probA: +pA.toFixed(4), probB: +pB.toFixed(4),
+    jointProbability: joint,
+    pAGivenB: pB > 0 ? +(joint / pB).toFixed(4) : null,
+    pBGivenA: pA > 0 ? +(joint / pA).toFixed(4) : null,
+    assumingIndependence: Math.abs(joint - pA * pB) < 0.01,
+  };
+}