@mcptoolshop/registry-stats 3.0.0 → 3.1.0

package/README.md

@@ -1,7 +1,7 @@
-<p align="center">
-  <a href="README.ja.md">日本語</a> | <a href="README.zh.md">中文</a> | <a href="README.es.md">Español</a> | <a href="README.fr.md">Français</a> | <a href="README.hi.md">हिन्दी</a> | <a href="README.it.md">Italiano</a> | <a href="README.pt-BR.md">Português (BR)</a>
-</p>
-
+<p align="center">
+  <a href="README.ja.md">日本語</a> | <a href="README.zh.md">中文</a> | <a href="README.es.md">Español</a> | <a href="README.fr.md">Français</a> | <a href="README.hi.md">हिन्दी</a> | <a href="README.it.md">Italiano</a> | <a href="README.pt-BR.md">Português (BR)</a>
+</p>
+
 <p align="center">
   <img src="https://raw.githubusercontent.com/mcp-tool-shop-org/brand/main/logos/registry-stats/readme.png" alt="registry-stats logo" width="400" />
 </p>
@@ -39,8 +39,8 @@ Zero runtime dependencies. Uses native `fetch()`. Node 18+.
 
 | Layer | What it does |
 |-------|-------------|
-| **Engine** | TypeScript library + CLI + REST server. Query five registries with one interface. Published to npm as `@mcptoolshop/registry-stats`. |
-| **Dashboard** | Astro-powered web app with Pulse AI co-pilot (streaming voice, web search, fullscreen, GitHub data connectors), six interactive charts, live refresh, export reports (PDF / JSONL / Markdown), and tabbed Help guide. Rebuilt weekly by CI; refreshable on demand. |
+| **Engine** | TypeScript library + CLI + REST server + AI inference. Query five registries with one interface. Published to npm as `@mcptoolshop/registry-stats`. |
+| **Dashboard** | Astro-powered web app with AI inference panel, Pulse AI co-pilot (streaming voice, web search, fullscreen, GitHub data connectors), six interactive charts, live refresh, export reports (PDF / JSONL / Markdown), and tabbed Help guide. Rebuilt daily by CI; refreshable on demand. |
 | **Desktop** | WinUI 3 + WebView2 native Windows app. Bundles the dashboard offline, fetches live stats on demand. |
 
 ## Dashboard
@@ -52,16 +52,56 @@ A self-updating stats dashboard lives at [`/dashboard/`](https://mcp-tool-shop-o
 - **Executive snapshot** — health score (0–100), diversity index, weekly change, total downloads across all registries
 - **Six interactive charts** — 30-day trend (aggregate / per-registry / top-5 toggles), registry share (polar area), portfolio risk (histogram + Gini & P90), top-10 momentum, velocity tracker with sparklines, and 30-day heatmap with spike detection (>2σ)
 - **Smart growth engine** — handles small-denominator distortion with baseline threshold, percentage cap, and damped velocity formula
+- **AI Inference Panel** — portfolio momentum (-100 to +100), risk score, 7-day forecast with confidence intervals, and automated recommendations (growth, risk, opportunity, attention)
 - **Actionable insights** — auto-generated recommendations and attention alerts for declining packages
 - **Pulse panel** — split view of Established Movers (≥ 50 downloads/wk) and Emerging & New packages, with inline 7-day sparklines, absolute + percentage deltas, baseline context, and a one-line executive summary
 - **Live refresh** — on-demand client-side fetch from npm and PyPI APIs with progress indicator; results cached in sessionStorage (5 min TTL) so tab switches are instant
 - **Export reports** — dropdown next to the Refresh button offering three formats: **Exec PDF** (via jsPDF), **LLM JSONL** (typed records for AI ingestion), and **Dev Markdown** (GFM tables)
 - **Leaderboard** — 132 packages ranked by weekly downloads with inline 30-day sparklines and smart trend badges
 - **Setup page** — portfolio editor with validation, registry-sync companion section, and pipeline overview
-- **Help tab** — human-friendly guide covering every tab, key concepts, AI assistant tips, data pipeline, and useful links
+- **Leaderboard search** — instant text filter for finding packages by name or registry
+- **Keyboard navigation** — arrow keys to cycle between tabs
+- **Help tab** — human-friendly guide covering every tab, key concepts, AI inference engine, data pipeline, and useful links
 - **Dark / light theme** — follows system preference
+- **Mobile responsive** — hamburger menu for small screens
+
+Data is fetched at build time and rebuilt daily by CI (06:00 UTC). Live refresh pulls the latest numbers directly from registry APIs. Configure tracked packages in `site/src/data/packages.json`.
+
+## AI Inference Engine
+
+Zero-dependency, pure-math inference that runs at build time — no ML runtime, no external APIs.
+
+```typescript
+import {
+  forecast, detectAnomalies, segmentTrends,
+  detectSeasonality, computeMomentum,
+  generateRecommendations, inferPortfolio,
+} from '@mcptoolshop/registry-stats';
+
+// 7-day forecast with 80% confidence intervals
+const predictions = forecast(dailySeries, 7);
+// → [{ day: 1, predicted: 142, lower: 98, upper: 186 }, ...]
+
+// Anomaly detection (adaptive rolling z-score, 14-day window)
+const anomalies = detectAnomalies(dailySeries);
+// → [{ day: 20, value: 1500, expected: 120, zscore: 4.2, type: 'spike' }]
+
+// Composite momentum score (-100 to +100)
+const momentum = computeMomentum(dailySeries);
+
+// Full portfolio analysis
+const result = inferPortfolio(leaderboard, { gini: 0.6, npmPct: 85 });
+// → { packages, forecastTotal7, riskScore, portfolioMomentum, recommendations }
+```
 
-Data is fetched at build time and rebuilt weekly by CI (Mondays 06:00 UTC). Live refresh pulls the latest numbers directly from registry APIs. Configure tracked packages in `site/src/data/packages.json` (132 packages across 5 registries).
+| Capability | Method | What it does |
+|-----------|--------|-------------|
+| **Forecast** | Weighted linear regression | Exponential recency bias, 80% CI that widens over time |
+| **Anomaly detection** | Adaptive rolling z-score | 14-day baseline window, detects spikes and drops |
+| **Trend segmentation** | Piecewise linear | Identifies up/down/flat segments in time series |
+| **Seasonality** | Day-of-week decomposition | Detects weekly patterns, reports peak day |
+| **Momentum** | Composite score | Direction + acceleration + consistency + volume |
+| **Recommendations** | Rule engine | Growth, risk, opportunity, and attention categories |
 
 ## Desktop App
 
@@ -212,8 +252,10 @@ await stats('npm', 'express', { cache });  // cache hit
 
 - Automatic retry with exponential backoff on 429/5xx errors
 - Respects `Retry-After` headers
+- 30-second request timeouts via `AbortSignal.timeout`
 - Concurrency limiting for bulk requests
 - Optional TTL cache (pluggable — bring your own Redis/file backend via `StatsCache` interface)
+- SHA-pinned GitHub Actions for supply chain security
 
 ## REST API Server
 

package/dist/cli.js

@@ -40,7 +40,7 @@ async function fetchWithRetry(url, registry, init) {
   let lastError;
   for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
     await acquireSlot(registry);
-    const res = await fetch(url, init);
+    const res = await fetch(url, { signal: AbortSignal.timeout(3e4), ...init });
     if (res.status === 404) return null;
     if (res.ok) return res.json();
     const retryAfter = res.headers.get("retry-after");
@@ -62,7 +62,7 @@ async function fetchWithRetry(url, registry, init) {
 async function fetchDirect(url, registry, init) {
   let lastError;
   for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
-    const res = await fetch(url, init);
+    const res = await fetch(url, { signal: AbortSignal.timeout(3e4), ...init });
     if (res.status === 404) return null;
     if (res.ok) return res.json();
     const retryAfter = res.headers.get("retry-after");
@@ -284,7 +284,8 @@ var docker = {
     if (options?.dockerToken) {
       headers["Authorization"] = `Bearer ${options.dockerToken}`;
     }
-    const json2 = await fetchWithRetry(`${API4}/${pkg}`, "docker", { headers });
+    const safePkg = pkg.split("/").map((s) => encodeURIComponent(s)).join("/");
+    const json2 = await fetchWithRetry(`${API4}/${safePkg}`, "docker", { headers });
     if (!json2 || !json2.name || !json2.namespace) return null;
     return {
       registry: "docker",

package/dist/index.cjs

@@ -22,11 +22,18 @@ var index_exports = {};
 __export(index_exports, {
   RegistryError: () => RegistryError,
   calc: () => calc,
+  computeMomentum: () => computeMomentum,
   createCache: () => createCache,
   createHandler: () => createHandler,
   defaultConfig: () => defaultConfig,
+  detectAnomalies: () => detectAnomalies,
+  detectSeasonality: () => detectSeasonality,
+  forecast: () => forecast,
+  generateRecommendations: () => generateRecommendations,
+  inferPortfolio: () => inferPortfolio,
   loadConfig: () => loadConfig,
   registerProvider: () => registerProvider,
+  segmentTrends: () => segmentTrends,
   serve: () => serve,
   starterConfig: () => starterConfig,
   stats: () => stats
@@ -69,7 +76,7 @@ async function fetchWithRetry(url, registry, init) {
   let lastError;
   for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
     await acquireSlot(registry);
-    const res = await fetch(url, init);
+    const res = await fetch(url, { signal: AbortSignal.timeout(3e4), ...init });
     if (res.status === 404) return null;
     if (res.ok) return res.json();
     const retryAfter = res.headers.get("retry-after");
@@ -91,7 +98,7 @@ async function fetchWithRetry(url, registry, init) {
 async function fetchDirect(url, registry, init) {
   let lastError;
   for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
-    const res = await fetch(url, init);
+    const res = await fetch(url, { signal: AbortSignal.timeout(3e4), ...init });
     if (res.status === 404) return null;
     if (res.ok) return res.json();
     const retryAfter = res.headers.get("retry-after");
@@ -313,7 +320,8 @@ var docker = {
     if (options?.dockerToken) {
       headers["Authorization"] = `Bearer ${options.dockerToken}`;
     }
-    const json2 = await fetchWithRetry(`${API4}/${pkg}`, "docker", { headers });
+    const safePkg = pkg.split("/").map((s) => encodeURIComponent(s)).join("/");
+    const json2 = await fetchWithRetry(`${API4}/${safePkg}`, "docker", { headers });
     if (!json2 || !json2.name || !json2.namespace) return null;
     return {
       registry: "docker",
@@ -600,6 +608,299 @@ Endpoints:`);
   return server;
 }
 
+// src/inference.ts
+function mean(arr) {
+  if (arr.length === 0) return 0;
+  return arr.reduce((a, b) => a + b, 0) / arr.length;
+}
+function stddev(arr) {
+  if (arr.length < 2) return 0;
+  const m = mean(arr);
+  const variance = arr.reduce((s, v) => s + (v - m) ** 2, 0) / arr.length;
+  return Math.sqrt(variance);
+}
+function linearRegression(ys) {
+  const n = ys.length;
+  if (n < 2) return { slope: 0, intercept: ys[0] ?? 0, r2: 0 };
+  let sumX = 0, sumY = 0, sumXY = 0, sumX2 = 0;
+  for (let i = 0; i < n; i++) {
+    sumX += i;
+    sumY += ys[i];
+    sumXY += i * ys[i];
+    sumX2 += i * i;
+  }
+  const denom = n * sumX2 - sumX * sumX;
+  if (denom === 0) return { slope: 0, intercept: sumY / n, r2: 0 };
+  const slope = (n * sumXY - sumX * sumY) / denom;
+  const intercept = (sumY - slope * sumX) / n;
+  const meanY = sumY / n;
+  let ssTot = 0, ssRes = 0;
+  for (let i = 0; i < n; i++) {
+    ssTot += (ys[i] - meanY) ** 2;
+    ssRes += (ys[i] - (intercept + slope * i)) ** 2;
+  }
+  const r2 = ssTot > 0 ? 1 - ssRes / ssTot : 0;
+  return { slope, intercept, r2 };
+}
+var DAY_NAMES = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+function forecast(series, days = 7) {
+  if (series.length < 7) return [];
+  const window = series.slice(-Math.min(14, series.length));
+  const n = window.length;
+  const weights = window.map((_, i) => Math.exp(0.1 * (i - n + 1)));
+  const totalW = weights.reduce((a, b) => a + b, 0);
+  let wSumX = 0, wSumY = 0, wSumXY = 0, wSumX2 = 0;
+  for (let i = 0; i < n; i++) {
+    const w = weights[i];
+    wSumX += w * i;
+    wSumY += w * window[i];
+    wSumXY += w * i * window[i];
+    wSumX2 += w * i * i;
+  }
+  const denom = totalW * wSumX2 - wSumX * wSumX;
+  let slope, intercept;
+  if (Math.abs(denom) < 1e-10) {
+    slope = 0;
+    intercept = wSumY / totalW;
+  } else {
+    slope = (totalW * wSumXY - wSumX * wSumY) / denom;
+    intercept = (wSumY - slope * wSumX) / totalW;
+  }
+  let ssRes = 0;
+  for (let i = 0; i < n; i++) {
+    ssRes += weights[i] * (window[i] - (intercept + slope * i)) ** 2;
+  }
+  const rse = Math.sqrt(ssRes / Math.max(1, totalW - 2));
+  const z80 = 1.28;
+  const results = [];
+  for (let d = 1; d <= days; d++) {
+    const x = n - 1 + d;
+    const predicted = Math.max(0, Math.round(intercept + slope * x));
+    const margin = Math.round(z80 * rse * Math.sqrt(1 + 1 / n + (x - n / 2) ** 2 / (n * n / 12)));
+    results.push({
+      day: d,
+      predicted,
+      lower: Math.max(0, predicted - margin),
+      upper: predicted + margin
+    });
+  }
+  return results;
+}
+function detectAnomalies(series, threshold = 2) {
+  if (series.length < 7) return [];
+  const anomalies = [];
+  const windowSize = Math.min(14, Math.floor(series.length * 0.7));
+  for (let i = windowSize; i < series.length; i++) {
+    const window = series.slice(i - windowSize, i);
+    const m = mean(window);
+    const s = stddev(window);
+    if (s < 1) continue;
+    const zscore = (series[i] - m) / s;
+    if (Math.abs(zscore) >= threshold) {
+      anomalies.push({
+        day: i,
+        value: series[i],
+        expected: Math.round(m),
+        zscore: Math.round(zscore * 10) / 10,
+        type: zscore > 0 ? "spike" : "drop"
+      });
+    }
+  }
+  return anomalies;
+}
+function segmentTrends(series, minSegmentLength = 5) {
+  if (series.length < minSegmentLength) return [];
+  const segments = [];
+  let segStart = 0;
+  while (segStart < series.length - minSegmentLength + 1) {
+    let bestEnd = segStart + minSegmentLength - 1;
+    const initialSlope = linearRegression(series.slice(segStart, segStart + minSegmentLength)).slope;
+    const initialDir = initialSlope > 0.5 ? "up" : initialSlope < -0.5 ? "down" : "flat";
+    for (let end = segStart + minSegmentLength; end < series.length; end++) {
+      const seg2 = series.slice(segStart, end + 1);
+      const { slope: slope2 } = linearRegression(seg2);
+      const dir = slope2 > 0.5 ? "up" : slope2 < -0.5 ? "down" : "flat";
+      if (dir !== initialDir) break;
+      bestEnd = end;
+    }
+    const seg = series.slice(segStart, bestEnd + 1);
+    const { slope } = linearRegression(seg);
+    const direction = slope > 0.5 ? "up" : slope < -0.5 ? "down" : "flat";
+    segments.push({
+      start: segStart,
+      end: bestEnd,
+      direction,
+      slope: Math.round(slope * 10) / 10,
+      magnitude: Math.round(seg[seg.length - 1] - seg[0])
+    });
+    segStart = bestEnd + 1;
+  }
+  return segments;
+}
+function detectSeasonality(series, startDaysAgo) {
+  if (series.length < 14) return null;
+  const buckets = [[], [], [], [], [], [], []];
+  const today = /* @__PURE__ */ new Date();
+  for (let i = 0; i < series.length; i++) {
+    const date = new Date(today);
+    date.setDate(date.getDate() - (startDaysAgo - i));
+    const dow = date.getDay();
+    buckets[dow].push(series[i]);
+  }
+  const dayAvgs = buckets.map((b) => Math.round(mean(b)));
+  const overallMean = mean(dayAvgs);
+  const maxAvg = Math.max(...dayAvgs);
+  const minAvg = Math.min(...dayAvgs);
+  if (overallMean < 1 || (maxAvg - minAvg) / overallMean < 0.15) return null;
+  const peakIdx = dayAvgs.indexOf(maxAvg);
+  return {
+    dayOfWeek: dayAvgs,
+    peakDay: DAY_NAMES[peakIdx]
+  };
+}
+function computeMomentum(series) {
+  if (series.length < 14) return 0;
+  const last7 = series.slice(-7);
+  const prev7 = series.slice(-14, -7);
+  const last7Sum = last7.reduce((a, b) => a + b, 0);
+  const prev7Sum = prev7.reduce((a, b) => a + b, 0);
+  const dampK = 10;
+  const dirScore = prev7Sum > dampK ? Math.max(-40, Math.min(40, (last7Sum - prev7Sum) / Math.sqrt(prev7Sum + dampK) * 4)) : last7Sum > 0 ? 20 : 0;
+  const { slope: recentSlope } = linearRegression(last7);
+  const { slope: prevSlope } = linearRegression(prev7);
+  const accelScore = Math.max(-20, Math.min(20, (recentSlope - prevSlope) * 2));
+  const cv = last7Sum > 0 ? stddev(last7) / mean(last7) : 1;
+  const consistencyScore = Math.max(0, 20 - cv * 20);
+  const volumeScore = last7Sum > 0 ? Math.min(20, Math.log10(last7Sum + 1) * 5) : 0;
+  return Math.round(Math.max(-100, Math.min(100, dirScore + accelScore + consistencyScore + volumeScore)));
+}
+function generateRecommendations(packages, opts = {}) {
+  const recs = [];
+  const declining = packages.filter((p) => p.momentum < -30);
+  if (declining.length > 0) {
+    const names = declining.slice(0, 3).map((p) => p.name).join(", ");
+    recs.push({
+      type: "attention",
+      priority: declining.some((p) => p.momentum < -60) ? "high" : "medium",
+      title: `${declining.length} package${declining.length > 1 ? "s" : ""} losing momentum`,
+      detail: `${names}${declining.length > 3 ? ` and ${declining.length - 3} more` : ""} show sustained decline. Consider: release updates, fix open issues, or update documentation.`,
+      metric: `Worst momentum: ${Math.min(...declining.map((p) => p.momentum))}`
+    });
+  }
+  if (opts.gini !== void 0 && opts.gini > 0.7) {
+    recs.push({
+      type: "risk",
+      priority: opts.gini > 0.85 ? "high" : "medium",
+      title: "High portfolio concentration",
+      detail: `Gini coefficient ${opts.gini.toFixed(2)} indicates downloads are heavily concentrated in a few packages. Diversify promotion efforts across the portfolio.`,
+      metric: `Gini: ${opts.gini.toFixed(2)}`
+    });
+  }
+  if (opts.npmPct !== void 0 && opts.npmPct > 75) {
+    recs.push({
+      type: "risk",
+      priority: "medium",
+      title: "Heavy npm dependency",
+      detail: `${opts.npmPct}% of downloads come from npm. Consider cross-publishing to PyPI and NuGet to reduce single-registry risk.`,
+      metric: `npm share: ${opts.npmPct}%`
+    });
+  }
+  const growing = packages.filter((p) => p.momentum > 40 && p.anomalies.some((a) => a.type === "spike"));
+  if (growing.length > 0) {
+    const names = growing.slice(0, 3).map((p) => p.name).join(", ");
+    recs.push({
+      type: "opportunity",
+      priority: "medium",
+      title: `${growing.length} package${growing.length > 1 ? "s" : ""} gaining traction`,
+      detail: `${names} show organic growth with download spikes. Capitalize with blog posts, social media, or conference talks.`,
+      metric: `Best momentum: ${Math.max(...growing.map((p) => p.momentum))}`
+    });
+  }
+  const forecastGrowing = packages.filter((p) => {
+    if (p.forecast7.length < 7) return false;
+    const lastActual = p.forecast7[0]?.predicted ?? 0;
+    const lastForecast = p.forecast7[6]?.predicted ?? 0;
+    return lastForecast > lastActual * 1.2;
+  });
+  if (forecastGrowing.length > 0) {
+    recs.push({
+      type: "growth",
+      priority: "low",
+      title: `${forecastGrowing.length} package${forecastGrowing.length > 1 ? "s" : ""} predicted to grow`,
+      detail: `Statistical models predict >20% growth in the next 7 days for ${forecastGrowing.slice(0, 3).map((p) => p.name).join(", ")}.`
+    });
+  }
+  const spiked = packages.filter((p) => p.anomalies.filter((a) => a.type === "spike").length >= 2);
+  if (spiked.length > 0) {
+    recs.push({
+      type: "attention",
+      priority: "low",
+      title: `${spiked.length} package${spiked.length > 1 ? "s" : ""} with repeated spikes`,
+      detail: `Multiple download spikes detected for ${spiked.slice(0, 3).map((p) => p.name).join(", ")}. Could indicate bot activity, viral posts, or dependency adoption.`
+    });
+  }
+  const priorityOrder = { high: 0, medium: 1, low: 2 };
+  recs.sort((a, b) => priorityOrder[a.priority] - priorityOrder[b.priority]);
+  return recs;
+}
+function inferPortfolio(leaderboard, opts = {}) {
+  const packages = [];
+  for (const row of leaderboard) {
+    const series = row.range30;
+    if (!series || series.length < 7) {
+      packages.push({
+        name: row.name,
+        registry: row.registry,
+        forecast7: [],
+        anomalies: [],
+        trendSegments: [],
+        seasonality: null,
+        momentum: 0
+      });
+      continue;
+    }
+    packages.push({
+      name: row.name,
+      registry: row.registry,
+      forecast7: forecast(series, 7),
+      anomalies: detectAnomalies(series),
+      trendSegments: segmentTrends(series),
+      seasonality: detectSeasonality(series, 30),
+      momentum: computeMomentum(series)
+    });
+  }
+  const forecastTotal7 = new Array(7).fill(0);
+  for (const pkg of packages) {
+    for (const pt of pkg.forecast7) {
+      forecastTotal7[pt.day - 1] += pt.predicted;
+    }
+  }
+  const totalWeek = leaderboard.reduce((s, r) => s + (r.week ?? 0), 0);
+  let weightedMomentum = 0;
+  for (const pkg of packages) {
+    const row = leaderboard.find((r) => r.name === pkg.name);
+    const weight = totalWeek > 0 ? (row?.week ?? 0) / totalWeek : 1 / packages.length;
+    weightedMomentum += pkg.momentum * weight;
+  }
+  const decliningPct = packages.filter((p) => p.momentum < -20).length / Math.max(1, packages.length);
+  const totalAnomalies = packages.reduce((s, p) => s + p.anomalies.length, 0);
+  const anomalyDensity = totalAnomalies / Math.max(1, packages.length);
+  const giniRisk = (opts.gini ?? 0) * 30;
+  const declineRisk = decliningPct * 40;
+  const anomalyRisk = Math.min(30, anomalyDensity * 10);
+  const riskScore = Math.round(Math.max(0, Math.min(100, giniRisk + declineRisk + anomalyRisk)));
+  const diversityTrend = "stable";
+  const recommendations = generateRecommendations(packages, opts);
+  return {
+    packages,
+    recommendations,
+    forecastTotal7,
+    riskScore,
+    diversityTrend,
+    portfolioMomentum: Math.round(weightedMomentum)
+  };
+}
+
 // src/index.ts
 function createCache() {
   const store = /* @__PURE__ */ new Map();
@@ -797,11 +1098,18 @@ stats.mine = async function mine(maintainer, options) {
 0 && (module.exports = {
   RegistryError,
   calc,
+  computeMomentum,
   createCache,
   createHandler,
   defaultConfig,
+  detectAnomalies,
+  detectSeasonality,
+  forecast,
+  generateRecommendations,
+  inferPortfolio,
   loadConfig,
   registerProvider,
+  segmentTrends,
   serve,
   starterConfig,
   stats

package/dist/index.d.cts

@@ -116,6 +116,113 @@ declare function createHandler(opts?: StatsOptions): Handler;
 /** Starts an HTTP server. Returns the server instance. */
 declare function serve(opts?: ServerOptions): node_http.Server<typeof IncomingMessage, typeof ServerResponse>;
 
+/**
+ * AI Inference Module — statistical forecasting, anomaly detection, and recommendations.
+ *
+ * Zero dependencies. Pure math on time-series data arrays.
+ * Designed to run at build-time in the fetch-stats pipeline.
+ */
+interface ForecastPoint {
+    day: number;
+    predicted: number;
+    lower: number;
+    upper: number;
+}
+interface Anomaly {
+    day: number;
+    value: number;
+    expected: number;
+    zscore: number;
+    type: 'spike' | 'drop';
+}
+interface TrendSegment {
+    start: number;
+    end: number;
+    direction: 'up' | 'down' | 'flat';
+    slope: number;
+    magnitude: number;
+}
+interface Recommendation {
+    type: 'growth' | 'risk' | 'opportunity' | 'attention';
+    priority: 'high' | 'medium' | 'low';
+    title: string;
+    detail: string;
+    metric?: string;
+}
+interface PackageInference {
+    name: string;
+    registry: string;
+    forecast7: ForecastPoint[];
+    anomalies: Anomaly[];
+    trendSegments: TrendSegment[];
+    seasonality: {
+        dayOfWeek: number[];
+        peakDay: string;
+    } | null;
+    momentum: number;
+}
+interface PortfolioInference {
+    packages: PackageInference[];
+    recommendations: Recommendation[];
+    forecastTotal7: number[];
+    riskScore: number;
+    diversityTrend: 'improving' | 'stable' | 'declining';
+    portfolioMomentum: number;
+}
+/**
+ * Forecast next N days using weighted linear regression on recent data.
+ * Uses the last 14 days with exponential weighting (recent days matter more).
+ * Returns predictions with 80% confidence intervals.
+ */
+declare function forecast(series: number[], days?: number): ForecastPoint[];
+/**
+ * Detect anomalies using adaptive z-score with rolling baseline.
+ * More sophisticated than simple global z-score — uses a 14-day rolling
+ * window so seasonal patterns don't trigger false positives.
+ */
+declare function detectAnomalies(series: number[], threshold?: number): Anomaly[];
+/**
+ * Segment a time series into directional trend segments.
+ * Uses a simple piecewise linear approach with minimum segment length.
+ */
+declare function segmentTrends(series: number[], minSegmentLength?: number): TrendSegment[];
+/**
+ * Detect day-of-week seasonality patterns.
+ * Requires at least 14 days of data to identify weekly cycles.
+ */
+declare function detectSeasonality(series: number[], startDaysAgo: number): {
+    dayOfWeek: number[];
+    peakDay: string;
+} | null;
+/**
+ * Compute a composite momentum score (-100 to +100).
+ * Combines: short-term trend, acceleration, volume, and consistency.
+ */
+declare function computeMomentum(series: number[]): number;
+/**
+ * Generate automated recommendations based on portfolio analysis.
+ */
+declare function generateRecommendations(packages: PackageInference[], opts?: {
+    gini?: number;
+    npmPct?: number;
+    totalWeekly?: number;
+}): Recommendation[];
+/**
+ * Run full inference pipeline on a leaderboard dataset.
+ * This is the main entry point called from fetch-stats.mjs.
+ */
+declare function inferPortfolio(leaderboard: Array<{
+    name: string;
+    registry: string;
+    week: number;
+    range30?: number[] | null;
+    trendPct?: number | null;
+}>, opts?: {
+    gini?: number;
+    npmPct?: number;
+    totalWeekly?: number;
+}): PortfolioInference;
+
 declare function createCache(): StatsCache;
 
 declare function registerProvider(provider: RegistryProvider): void;
@@ -130,4 +237,4 @@ declare namespace stats {
     }) => Promise<PackageStats[]>;
 }
 
-export { type ChartData, type ComparisonResult, type Config, type DailyDownloads, type PackageConfig, type PackageStats, type RateLimitConfig, RegistryError, type RegistryName, type RegistryProvider, type ServerOptions, type StatsCache, type StatsOptions, calc, createCache, createHandler, defaultConfig, loadConfig, registerProvider, serve, starterConfig, stats };
+export { type Anomaly, type ChartData, type ComparisonResult, type Config, type DailyDownloads, type ForecastPoint, type PackageConfig, type PackageInference, type PackageStats, type PortfolioInference, type RateLimitConfig, type Recommendation, RegistryError, type RegistryName, type RegistryProvider, type ServerOptions, type StatsCache, type StatsOptions, type TrendSegment, calc, computeMomentum, createCache, createHandler, defaultConfig, detectAnomalies, detectSeasonality, forecast, generateRecommendations, inferPortfolio, loadConfig, registerProvider, segmentTrends, serve, starterConfig, stats };

package/dist/index.d.ts

@@ -116,6 +116,113 @@ declare function createHandler(opts?: StatsOptions): Handler;
 /** Starts an HTTP server. Returns the server instance. */
 declare function serve(opts?: ServerOptions): node_http.Server<typeof IncomingMessage, typeof ServerResponse>;
 
+/**
+ * AI Inference Module — statistical forecasting, anomaly detection, and recommendations.
+ *
+ * Zero dependencies. Pure math on time-series data arrays.
+ * Designed to run at build-time in the fetch-stats pipeline.
+ */
+interface ForecastPoint {
+    day: number;
+    predicted: number;
+    lower: number;
+    upper: number;
+}
+interface Anomaly {
+    day: number;
+    value: number;
+    expected: number;
+    zscore: number;
+    type: 'spike' | 'drop';
+}
+interface TrendSegment {
+    start: number;
+    end: number;
+    direction: 'up' | 'down' | 'flat';
+    slope: number;
+    magnitude: number;
+}
+interface Recommendation {
+    type: 'growth' | 'risk' | 'opportunity' | 'attention';
+    priority: 'high' | 'medium' | 'low';
+    title: string;
+    detail: string;
+    metric?: string;
+}
+interface PackageInference {
+    name: string;
+    registry: string;
+    forecast7: ForecastPoint[];
+    anomalies: Anomaly[];
+    trendSegments: TrendSegment[];
+    seasonality: {
+        dayOfWeek: number[];
+        peakDay: string;
+    } | null;
+    momentum: number;
+}
+interface PortfolioInference {
+    packages: PackageInference[];
+    recommendations: Recommendation[];
+    forecastTotal7: number[];
+    riskScore: number;
+    diversityTrend: 'improving' | 'stable' | 'declining';
+    portfolioMomentum: number;
+}
+/**
+ * Forecast next N days using weighted linear regression on recent data.
+ * Uses the last 14 days with exponential weighting (recent days matter more).
+ * Returns predictions with 80% confidence intervals.
+ */
+declare function forecast(series: number[], days?: number): ForecastPoint[];
+/**
+ * Detect anomalies using adaptive z-score with rolling baseline.
+ * More sophisticated than simple global z-score — uses a 14-day rolling
+ * window so seasonal patterns don't trigger false positives.
+ */
+declare function detectAnomalies(series: number[], threshold?: number): Anomaly[];
+/**
+ * Segment a time series into directional trend segments.
+ * Uses a simple piecewise linear approach with minimum segment length.
+ */
+declare function segmentTrends(series: number[], minSegmentLength?: number): TrendSegment[];
+/**
+ * Detect day-of-week seasonality patterns.
+ * Requires at least 14 days of data to identify weekly cycles.
+ */
+declare function detectSeasonality(series: number[], startDaysAgo: number): {
+    dayOfWeek: number[];
+    peakDay: string;
+} | null;
+/**
+ * Compute a composite momentum score (-100 to +100).
+ * Combines: short-term trend, acceleration, volume, and consistency.
+ */
+declare function computeMomentum(series: number[]): number;
+/**
+ * Generate automated recommendations based on portfolio analysis.
+ */
+declare function generateRecommendations(packages: PackageInference[], opts?: {
+    gini?: number;
+    npmPct?: number;
+    totalWeekly?: number;
+}): Recommendation[];
+/**
+ * Run full inference pipeline on a leaderboard dataset.
+ * This is the main entry point called from fetch-stats.mjs.
+ */
+declare function inferPortfolio(leaderboard: Array<{
+    name: string;
+    registry: string;
+    week: number;
+    range30?: number[] | null;
+    trendPct?: number | null;
+}>, opts?: {
+    gini?: number;
+    npmPct?: number;
+    totalWeekly?: number;
+}): PortfolioInference;
+
 declare function createCache(): StatsCache;
 
 declare function registerProvider(provider: RegistryProvider): void;
@@ -130,4 +237,4 @@ declare namespace stats {
     }) => Promise<PackageStats[]>;
 }
 
-export { type ChartData, type ComparisonResult, type Config, type DailyDownloads, type PackageConfig, type PackageStats, type RateLimitConfig, RegistryError, type RegistryName, type RegistryProvider, type ServerOptions, type StatsCache, type StatsOptions, calc, createCache, createHandler, defaultConfig, loadConfig, registerProvider, serve, starterConfig, stats };
+export { type Anomaly, type ChartData, type ComparisonResult, type Config, type DailyDownloads, type ForecastPoint, type PackageConfig, type PackageInference, type PackageStats, type PortfolioInference, type RateLimitConfig, type Recommendation, RegistryError, type RegistryName, type RegistryProvider, type ServerOptions, type StatsCache, type StatsOptions, type TrendSegment, calc, computeMomentum, createCache, createHandler, defaultConfig, detectAnomalies, detectSeasonality, forecast, generateRecommendations, inferPortfolio, loadConfig, registerProvider, segmentTrends, serve, starterConfig, stats };

package/dist/index.js

@@ -34,7 +34,7 @@ async function fetchWithRetry(url, registry, init) {
   let lastError;
   for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
     await acquireSlot(registry);
-    const res = await fetch(url, init);
+    const res = await fetch(url, { signal: AbortSignal.timeout(3e4), ...init });
     if (res.status === 404) return null;
     if (res.ok) return res.json();
     const retryAfter = res.headers.get("retry-after");
@@ -56,7 +56,7 @@ async function fetchWithRetry(url, registry, init) {
 async function fetchDirect(url, registry, init) {
   let lastError;
   for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
-    const res = await fetch(url, init);
+    const res = await fetch(url, { signal: AbortSignal.timeout(3e4), ...init });
     if (res.status === 404) return null;
     if (res.ok) return res.json();
     const retryAfter = res.headers.get("retry-after");
@@ -278,7 +278,8 @@ var docker = {
     if (options?.dockerToken) {
       headers["Authorization"] = `Bearer ${options.dockerToken}`;
     }
-    const json2 = await fetchWithRetry(`${API4}/${pkg}`, "docker", { headers });
+    const safePkg = pkg.split("/").map((s) => encodeURIComponent(s)).join("/");
+    const json2 = await fetchWithRetry(`${API4}/${safePkg}`, "docker", { headers });
     if (!json2 || !json2.name || !json2.namespace) return null;
     return {
       registry: "docker",
@@ -565,6 +566,299 @@ Endpoints:`);
   return server;
 }
 
+// src/inference.ts
+function mean(arr) {
+  if (arr.length === 0) return 0;
+  return arr.reduce((a, b) => a + b, 0) / arr.length;
+}
+function stddev(arr) {
+  if (arr.length < 2) return 0;
+  const m = mean(arr);
+  const variance = arr.reduce((s, v) => s + (v - m) ** 2, 0) / arr.length;
+  return Math.sqrt(variance);
+}
+function linearRegression(ys) {
+  const n = ys.length;
+  if (n < 2) return { slope: 0, intercept: ys[0] ?? 0, r2: 0 };
+  let sumX = 0, sumY = 0, sumXY = 0, sumX2 = 0;
+  for (let i = 0; i < n; i++) {
+    sumX += i;
+    sumY += ys[i];
+    sumXY += i * ys[i];
+    sumX2 += i * i;
+  }
+  const denom = n * sumX2 - sumX * sumX;
+  if (denom === 0) return { slope: 0, intercept: sumY / n, r2: 0 };
+  const slope = (n * sumXY - sumX * sumY) / denom;
+  const intercept = (sumY - slope * sumX) / n;
+  const meanY = sumY / n;
+  let ssTot = 0, ssRes = 0;
+  for (let i = 0; i < n; i++) {
+    ssTot += (ys[i] - meanY) ** 2;
+    ssRes += (ys[i] - (intercept + slope * i)) ** 2;
+  }
+  const r2 = ssTot > 0 ? 1 - ssRes / ssTot : 0;
+  return { slope, intercept, r2 };
+}
+var DAY_NAMES = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+function forecast(series, days = 7) {
+  if (series.length < 7) return [];
+  const window = series.slice(-Math.min(14, series.length));
+  const n = window.length;
+  const weights = window.map((_, i) => Math.exp(0.1 * (i - n + 1)));
+  const totalW = weights.reduce((a, b) => a + b, 0);
+  let wSumX = 0, wSumY = 0, wSumXY = 0, wSumX2 = 0;
+  for (let i = 0; i < n; i++) {
+    const w = weights[i];
+    wSumX += w * i;
+    wSumY += w * window[i];
+    wSumXY += w * i * window[i];
+    wSumX2 += w * i * i;
+  }
+  const denom = totalW * wSumX2 - wSumX * wSumX;
+  let slope, intercept;
+  if (Math.abs(denom) < 1e-10) {
+    slope = 0;
+    intercept = wSumY / totalW;
+  } else {
+    slope = (totalW * wSumXY - wSumX * wSumY) / denom;
+    intercept = (wSumY - slope * wSumX) / totalW;
+  }
+  let ssRes = 0;
+  for (let i = 0; i < n; i++) {
+    ssRes += weights[i] * (window[i] - (intercept + slope * i)) ** 2;
+  }
+  const rse = Math.sqrt(ssRes / Math.max(1, totalW - 2));
+  const z80 = 1.28;
+  const results = [];
+  for (let d = 1; d <= days; d++) {
+    const x = n - 1 + d;
+    const predicted = Math.max(0, Math.round(intercept + slope * x));
+    const margin = Math.round(z80 * rse * Math.sqrt(1 + 1 / n + (x - n / 2) ** 2 / (n * n / 12)));
+    results.push({
+      day: d,
+      predicted,
+      lower: Math.max(0, predicted - margin),
+      upper: predicted + margin
+    });
+  }
+  return results;
+}
+function detectAnomalies(series, threshold = 2) {
+  if (series.length < 7) return [];
+  const anomalies = [];
+  const windowSize = Math.min(14, Math.floor(series.length * 0.7));
+  for (let i = windowSize; i < series.length; i++) {
+    const window = series.slice(i - windowSize, i);
+    const m = mean(window);
+    const s = stddev(window);
+    if (s < 1) continue;
+    const zscore = (series[i] - m) / s;
+    if (Math.abs(zscore) >= threshold) {
+      anomalies.push({
+        day: i,
+        value: series[i],
+        expected: Math.round(m),
+        zscore: Math.round(zscore * 10) / 10,
+        type: zscore > 0 ? "spike" : "drop"
+      });
+    }
+  }
+  return anomalies;
+}
+function segmentTrends(series, minSegmentLength = 5) {
+  if (series.length < minSegmentLength) return [];
+  const segments = [];
+  let segStart = 0;
+  while (segStart < series.length - minSegmentLength + 1) {
+    let bestEnd = segStart + minSegmentLength - 1;
+    const initialSlope = linearRegression(series.slice(segStart, segStart + minSegmentLength)).slope;
+    const initialDir = initialSlope > 0.5 ? "up" : initialSlope < -0.5 ? "down" : "flat";
+    for (let end = segStart + minSegmentLength; end < series.length; end++) {
+      const seg2 = series.slice(segStart, end + 1);
+      const { slope: slope2 } = linearRegression(seg2);
+      const dir = slope2 > 0.5 ? "up" : slope2 < -0.5 ? "down" : "flat";
+      if (dir !== initialDir) break;
+      bestEnd = end;
+    }
+    const seg = series.slice(segStart, bestEnd + 1);
+    const { slope } = linearRegression(seg);
+    const direction = slope > 0.5 ? "up" : slope < -0.5 ? "down" : "flat";
+    segments.push({
+      start: segStart,
+      end: bestEnd,
+      direction,
+      slope: Math.round(slope * 10) / 10,
+      magnitude: Math.round(seg[seg.length - 1] - seg[0])
+    });
+    segStart = bestEnd + 1;
+  }
+  return segments;
+}
+function detectSeasonality(series, startDaysAgo) {
+  if (series.length < 14) return null;
+  const buckets = [[], [], [], [], [], [], []];
+  const today = /* @__PURE__ */ new Date();
+  for (let i = 0; i < series.length; i++) {
+    const date = new Date(today);
+    date.setDate(date.getDate() - (startDaysAgo - i));
+    const dow = date.getDay();
+    buckets[dow].push(series[i]);
+  }
+  const dayAvgs = buckets.map((b) => Math.round(mean(b)));
+  const overallMean = mean(dayAvgs);
+  const maxAvg = Math.max(...dayAvgs);
+  const minAvg = Math.min(...dayAvgs);
+  if (overallMean < 1 || (maxAvg - minAvg) / overallMean < 0.15) return null;
+  const peakIdx = dayAvgs.indexOf(maxAvg);
+  return {
+    dayOfWeek: dayAvgs,
+    peakDay: DAY_NAMES[peakIdx]
+  };
+}
+function computeMomentum(series) {
+  if (series.length < 14) return 0;
+  const last7 = series.slice(-7);
+  const prev7 = series.slice(-14, -7);
+  const last7Sum = last7.reduce((a, b) => a + b, 0);
+  const prev7Sum = prev7.reduce((a, b) => a + b, 0);
+  const dampK = 10;
+  const dirScore = prev7Sum > dampK ? Math.max(-40, Math.min(40, (last7Sum - prev7Sum) / Math.sqrt(prev7Sum + dampK) * 4)) : last7Sum > 0 ? 20 : 0;
+  const { slope: recentSlope } = linearRegression(last7);
+  const { slope: prevSlope } = linearRegression(prev7);
+  const accelScore = Math.max(-20, Math.min(20, (recentSlope - prevSlope) * 2));
+  const cv = last7Sum > 0 ? stddev(last7) / mean(last7) : 1;
+  const consistencyScore = Math.max(0, 20 - cv * 20);
+  const volumeScore = last7Sum > 0 ? Math.min(20, Math.log10(last7Sum + 1) * 5) : 0;
+  return Math.round(Math.max(-100, Math.min(100, dirScore + accelScore + consistencyScore + volumeScore)));
+}
+function generateRecommendations(packages, opts = {}) {
+  const recs = [];
+  const declining = packages.filter((p) => p.momentum < -30);
+  if (declining.length > 0) {
+    const names = declining.slice(0, 3).map((p) => p.name).join(", ");
+    recs.push({
+      type: "attention",
+      priority: declining.some((p) => p.momentum < -60) ? "high" : "medium",
+      title: `${declining.length} package${declining.length > 1 ? "s" : ""} losing momentum`,
+      detail: `${names}${declining.length > 3 ? ` and ${declining.length - 3} more` : ""} show sustained decline. Consider: release updates, fix open issues, or update documentation.`,
+      metric: `Worst momentum: ${Math.min(...declining.map((p) => p.momentum))}`
+    });
+  }
+  if (opts.gini !== void 0 && opts.gini > 0.7) {
+    recs.push({
+      type: "risk",
+      priority: opts.gini > 0.85 ? "high" : "medium",
+      title: "High portfolio concentration",
+      detail: `Gini coefficient ${opts.gini.toFixed(2)} indicates downloads are heavily concentrated in a few packages. Diversify promotion efforts across the portfolio.`,
+      metric: `Gini: ${opts.gini.toFixed(2)}`
+    });
+  }
+  if (opts.npmPct !== void 0 && opts.npmPct > 75) {
+    recs.push({
+      type: "risk",
+      priority: "medium",
+      title: "Heavy npm dependency",
+      detail: `${opts.npmPct}% of downloads come from npm. Consider cross-publishing to PyPI and NuGet to reduce single-registry risk.`,
+      metric: `npm share: ${opts.npmPct}%`
+    });
+  }
+  const growing = packages.filter((p) => p.momentum > 40 && p.anomalies.some((a) => a.type === "spike"));
+  if (growing.length > 0) {
+    const names = growing.slice(0, 3).map((p) => p.name).join(", ");
+    recs.push({
+      type: "opportunity",
+      priority: "medium",
+      title: `${growing.length} package${growing.length > 1 ? "s" : ""} gaining traction`,
+      detail: `${names} show organic growth with download spikes. Capitalize with blog posts, social media, or conference talks.`,
+      metric: `Best momentum: ${Math.max(...growing.map((p) => p.momentum))}`
+    });
+  }
+  const forecastGrowing = packages.filter((p) => {
+    if (p.forecast7.length < 7) return false;
+    const lastActual = p.forecast7[0]?.predicted ?? 0;
+    const lastForecast = p.forecast7[6]?.predicted ?? 0;
+    return lastForecast > lastActual * 1.2;
+  });
+  if (forecastGrowing.length > 0) {
+    recs.push({
+      type: "growth",
+      priority: "low",
+      title: `${forecastGrowing.length} package${forecastGrowing.length > 1 ? "s" : ""} predicted to grow`,
+      detail: `Statistical models predict >20% growth in the next 7 days for ${forecastGrowing.slice(0, 3).map((p) => p.name).join(", ")}.`
+    });
+  }
+  const spiked = packages.filter((p) => p.anomalies.filter((a) => a.type === "spike").length >= 2);
+  if (spiked.length > 0) {
+    recs.push({
+      type: "attention",
+      priority: "low",
+      title: `${spiked.length} package${spiked.length > 1 ? "s" : ""} with repeated spikes`,
+      detail: `Multiple download spikes detected for ${spiked.slice(0, 3).map((p) => p.name).join(", ")}. Could indicate bot activity, viral posts, or dependency adoption.`
+    });
+  }
+  const priorityOrder = { high: 0, medium: 1, low: 2 };
+  recs.sort((a, b) => priorityOrder[a.priority] - priorityOrder[b.priority]);
+  return recs;
+}
+function inferPortfolio(leaderboard, opts = {}) {
+  const packages = [];
+  for (const row of leaderboard) {
+    const series = row.range30;
+    if (!series || series.length < 7) {
+      packages.push({
+        name: row.name,
+        registry: row.registry,
+        forecast7: [],
+        anomalies: [],
+        trendSegments: [],
+        seasonality: null,
+        momentum: 0
+      });
+      continue;
+    }
+    packages.push({
+      name: row.name,
+      registry: row.registry,
+      forecast7: forecast(series, 7),
+      anomalies: detectAnomalies(series),
+      trendSegments: segmentTrends(series),
+      seasonality: detectSeasonality(series, 30),
+      momentum: computeMomentum(series)
+    });
+  }
+  const forecastTotal7 = new Array(7).fill(0);
+  for (const pkg of packages) {
+    for (const pt of pkg.forecast7) {
+      forecastTotal7[pt.day - 1] += pt.predicted;
+    }
+  }
+  const totalWeek = leaderboard.reduce((s, r) => s + (r.week ?? 0), 0);
+  let weightedMomentum = 0;
+  for (const pkg of packages) {
+    const row = leaderboard.find((r) => r.name === pkg.name);
+    const weight = totalWeek > 0 ? (row?.week ?? 0) / totalWeek : 1 / packages.length;
+    weightedMomentum += pkg.momentum * weight;
+  }
+  const decliningPct = packages.filter((p) => p.momentum < -20).length / Math.max(1, packages.length);
+  const totalAnomalies = packages.reduce((s, p) => s + p.anomalies.length, 0);
+  const anomalyDensity = totalAnomalies / Math.max(1, packages.length);
+  const giniRisk = (opts.gini ?? 0) * 30;
+  const declineRisk = decliningPct * 40;
+  const anomalyRisk = Math.min(30, anomalyDensity * 10);
+  const riskScore = Math.round(Math.max(0, Math.min(100, giniRisk + declineRisk + anomalyRisk)));
+  const diversityTrend = "stable";
+  const recommendations = generateRecommendations(packages, opts);
+  return {
+    packages,
+    recommendations,
+    forecastTotal7,
+    riskScore,
+    diversityTrend,
+    portfolioMomentum: Math.round(weightedMomentum)
+  };
+}
+
 // src/index.ts
 function createCache() {
   const store = /* @__PURE__ */ new Map();
@@ -761,11 +1055,18 @@ stats.mine = async function mine(maintainer, options) {
 export {
   RegistryError,
   calc,
+  computeMomentum,
   createCache,
   createHandler,
   defaultConfig,
+  detectAnomalies,
+  detectSeasonality,
+  forecast,
+  generateRecommendations,
+  inferPortfolio,
   loadConfig,
   registerProvider,
+  segmentTrends,
   serve,
   starterConfig,
   stats

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mcptoolshop/registry-stats",
-  "version": "3.0.0",
+  "version": "3.1.0",
   "description": "Multi-registry download stats — engine, AI-powered dashboard, and desktop app for npm, PyPI, NuGet, VS Code Marketplace, and Docker Hub",
   "type": "module",
   "main": "./dist/index.cjs",