pongspeedtest 1.0.0

package/README.md

@@ -0,0 +1,109 @@
+# pong
+
+Fast internet speed test from your terminal. Ping, download, upload, jitter, bufferbloat, and experience scores.
+
+Zero dependencies. Works with Node.js 18+.
+
+## Install
+
+```bash
+npm install -g pong-speedtest
+```
+
+## Usage
+
+```bash
+# Full speed test
+pong
+
+# Choose a server
+pong --server lax
+
+# JSON output (for scripts and piping)
+pong --json
+
+# Compact one-line output
+pong --simple
+
+# Skip phases you don't need
+pong --skip upload,bloat
+
+# List available servers
+pong --list-servers
+```
+
+## Output
+
+```
+  ▸ pong speed test  —  Auto (Cloudflare Edge)
+  ────────────────────────────────────────────────
+
+  Ping       26.2 ms  (Good)
+  Jitter     2.1 ms   (Excellent)
+
+  Download   302 Mbps  (Excellent)
+
+  Upload     36.3 Mbps  (Good)
+
+  Bloat      Grade A  (+3ms under load)
+
+  ────────────────────────────────────────────────
+  Experience Scores
+
+  4K Video     ████████████████████ 100/100
+  Video Call   ██████████████████░░  89/100
+  Gaming       ██████████████████░░  89/100
+  Web          ███████████████████░  96/100
+
+  Share results: https://pong.com/results?src=cli&...
+
+  Powered by pong.com
+```
+
+## JSON Output
+
+```bash
+pong --json | jq .download
+```
+
+```json
+{
+  "server": { "code": "auto", "name": "Auto (Cloudflare Edge)" },
+  "ping": 26.2,
+  "jitter": 2.1,
+  "download": 302.4,
+  "upload": 36.3,
+  "bufferbloat": { "grade": "A", "bloatMs": 3.2 },
+  "scores": { "video4k": 100, "videoCall": 89, "gaming": 89, "web": 96 },
+  "resultsUrl": "https://pong.com/results?src=cli&..."
+}
+```
+
+## Servers
+
+| Code | Location |
+|------|----------|
+| auto | Cloudflare Edge (nearest, default) |
+| ewr  | Newark, US |
+| lax  | Los Angeles, US |
+| yyz  | Toronto, CA |
+| lhr  | London, GB |
+| fra  | Frankfurt, DE |
+| nrt  | Tokyo, JP |
+| sin  | Singapore, SG |
+| bom  | Mumbai, IN |
+| syd  | Sydney, AU |
+| gru  | Sao Paulo, BR |
+
+## What's Measured
+
+- **Ping**: Round-trip latency (trimmed mean of 20 samples)
+- **Jitter**: Latency variation (mean absolute deviation)
+- **Download**: Multi-stream download throughput
+- **Upload**: Multi-stream upload throughput
+- **Bufferbloat**: Latency increase under load (graded A through F)
+- **Experience Scores**: 4K Video, Video Call, Gaming, Web Browsing (0 to 100)
+
+## License
+
+MIT. By [pong.com](https://pong.com).

package/bin/pong.js

@@ -0,0 +1,370 @@
+#!/usr/bin/env node
+
+// ═══════════════════════════════════════════════════════════════════
+// pong — fast internet speed test from your terminal
+// https://pong.com
+// ═══════════════════════════════════════════════════════════════════
+
+import {
+  SERVERS,
+  runPing,
+  runDownload,
+  runUpload,
+  runBufferbloat,
+  scoreVideo4k,
+  scoreVideoCall,
+  scoreGaming,
+  scoreWeb,
+} from "../lib/speedtest.js";
+
+import {
+  c,
+  startSpinner,
+  stopSpinner,
+  progressBar,
+  ratingColor,
+  ratingLabel,
+  bloatColor,
+  scoreColor,
+  box,
+} from "../lib/ui.js";
+
+// ── Version ───────────────────────────────────────────────────────
+const VERSION = "1.0.0";
+
+// ── Argument parsing ──────────────────────────────────────────────
+const args = process.argv.slice(2);
+const flags = {
+  help: args.includes("--help") || args.includes("-h"),
+  version: args.includes("--version") || args.includes("-v"),
+  json: args.includes("--json"),
+  simple: args.includes("--simple"),
+  listServers: args.includes("--list-servers") || args.includes("--servers"),
+  noColor: args.includes("--no-color"),
+  server: null,
+  skip: new Set(),
+};
+
+// Parse --server <code>
+const serverIdx = args.findIndex((a) => a === "--server" || a === "-s");
+if (serverIdx !== -1 && args[serverIdx + 1]) {
+  flags.server = args[serverIdx + 1].toLowerCase();
+}
+
+// Parse --skip <phases>
+const skipIdx = args.findIndex((a) => a === "--skip");
+if (skipIdx !== -1 && args[skipIdx + 1]) {
+  args[skipIdx + 1].split(",").forEach((s) => flags.skip.add(s.trim().toLowerCase()));
+}
+
+// ── Help ──────────────────────────────────────────────────────────
+if (flags.help) {
+  console.log(`
+${c.bold}${c.cyan}pong${c.reset} ${c.dim}v${VERSION}${c.reset}  —  fast internet speed test
+
+${c.bold}USAGE${c.reset}
+  pong                     Run full speed test
+  pong --server lax        Use specific server
+  pong --json              Output results as JSON
+  pong --simple            Compact single-line output
+  pong --list-servers      Show available servers
+  pong --skip upload       Skip phases (ping,download,upload,bloat)
+
+${c.bold}OPTIONS${c.reset}
+  -s, --server <code>      Server code (default: auto)
+  --json                   JSON output (for scripts)
+  --simple                 One-line summary
+  --skip <phases>          Comma-separated phases to skip
+  --list-servers           List available test servers
+  --no-color               Disable colors
+  -v, --version            Show version
+  -h, --help               Show this help
+
+${c.bold}EXAMPLES${c.reset}
+  ${c.dim}$${c.reset} pong
+  ${c.dim}$${c.reset} pong --server nrt --json
+  ${c.dim}$${c.reset} pong --skip bloat,upload --simple
+
+${c.dim}https://pong.com${c.reset}
+`);
+  process.exit(0);
+}
+
+if (flags.version) {
+  console.log(VERSION);
+  process.exit(0);
+}
+
+// ── List servers ──────────────────────────────────────────────────
+if (flags.listServers) {
+  console.log(`\n${c.bold}  Available servers${c.reset}\n`);
+  for (const [code, srv] of Object.entries(SERVERS)) {
+    const tag = code === "auto" ? `${c.green}(default)${c.reset}` : "";
+    console.log(`  ${c.cyan}${code.padEnd(6)}${c.reset} ${srv.name} ${tag}`);
+  }
+  console.log();
+  process.exit(0);
+}
+
+// ── Resolve server ────────────────────────────────────────────────
+function resolveServer(code) {
+  if (!code || code === "auto") return SERVERS.auto;
+  const srv = SERVERS[code];
+  if (!srv) {
+    console.error(
+      `${c.red}Error:${c.reset} Unknown server "${code}". Use ${c.cyan}--list-servers${c.reset} to see options.`
+    );
+    process.exit(1);
+  }
+  return srv;
+}
+
+// ── Main ──────────────────────────────────────────────────────────
+async function main() {
+  const server = resolveServer(flags.server);
+  const base = server.url;
+  const ac = new AbortController();
+  const { signal } = ac;
+
+  // Handle Ctrl+C gracefully
+  process.on("SIGINT", () => {
+    ac.abort();
+    stopSpinner();
+    console.log(`\n\n  ${c.dim}Test cancelled.${c.reset}\n`);
+    process.exit(0);
+  });
+
+  const results = {
+    server: { code: server.code, name: server.name },
+    ping: null,
+    jitter: null,
+    download: null,
+    upload: null,
+    bufferbloat: null,
+    scores: null,
+    timestamp: new Date().toISOString(),
+  };
+
+  if (!flags.json && !flags.simple) {
+    console.log();
+    console.log(
+      `  ${c.bold}${c.cyan}▸ pong${c.reset} ${c.dim}speed test${c.reset}  ${c.dim}—${c.reset}  ${c.dim}${server.name}${c.reset}`
+    );
+    console.log(`  ${c.dim}${"─".repeat(48)}${c.reset}`);
+    console.log();
+  }
+
+  // ── Ping ──────────────────────────────────────────────────────
+  if (!flags.skip.has("ping")) {
+    if (!flags.json && !flags.simple) startSpinner("Measuring latency...");
+    let pingStarted = false;
+
+    const pingResult = await runPing(base, signal, (ms, i, total) => {
+      if (!flags.json && !flags.simple) {
+        if (!pingStarted) { stopSpinner(); pingStarted = true; }
+        progressBar("Ping", ms, "ms", 100);
+      }
+    });
+
+    stopSpinner();
+
+    if (pingResult) {
+      results.ping = Math.round(pingResult.ping * 100) / 100;
+      results.jitter = Math.round(pingResult.jitter * 100) / 100;
+
+      if (!flags.json && !flags.simple) {
+        const pc = ratingColor("ping", results.ping);
+        const jc = ratingColor("jitter", results.jitter);
+        console.log(
+          `  ${c.cyan}Ping      ${c.reset} ${pc}${c.bold}${results.ping.toFixed(1)}${c.reset} ${c.dim}ms${c.reset}  ${c.dim}(${ratingLabel("ping", results.ping)})${c.reset}`
+        );
+        console.log(
+          `  ${c.cyan}Jitter    ${c.reset} ${jc}${c.bold}${results.jitter.toFixed(1)}${c.reset} ${c.dim}ms${c.reset}  ${c.dim}(${ratingLabel("jitter", results.jitter)})${c.reset}`
+        );
+        console.log();
+      }
+    }
+  }
+
+  // ── Download ──────────────────────────────────────────────────
+  if (!flags.skip.has("download")) {
+    if (!flags.json && !flags.simple) startSpinner("Testing download speed...");
+    let dlStarted = false;
+
+    const dlResult = await runDownload(base, signal, (mbps) => {
+      if (!flags.json && !flags.simple) {
+        if (!dlStarted) { stopSpinner(); dlStarted = true; }
+        progressBar("Download", mbps, "Mbps", 500);
+      }
+    });
+
+    stopSpinner();
+
+    if (dlResult) {
+      results.download = Math.round(dlResult * 100) / 100;
+
+      if (!flags.json && !flags.simple) {
+        const dc = ratingColor("speed", results.download);
+        console.log(
+          `  ${c.cyan}Download  ${c.reset} ${dc}${c.bold}${formatSpeed(results.download)}${c.reset} ${c.dim}Mbps${c.reset}  ${c.dim}(${ratingLabel("speed", results.download)})${c.reset}`
+        );
+        console.log();
+      }
+    }
+  }
+
+  // ── Upload ────────────────────────────────────────────────────
+  if (!flags.skip.has("upload")) {
+    if (!flags.json && !flags.simple) startSpinner("Testing upload speed...");
+    let ulStarted = false;
+
+    const ulResult = await runUpload(base, signal, (mbps) => {
+      if (!flags.json && !flags.simple) {
+        if (!ulStarted) { stopSpinner(); ulStarted = true; }
+        progressBar("Upload", mbps, "Mbps", 200);
+      }
+    });
+
+    stopSpinner();
+
+    if (ulResult) {
+      results.upload = Math.round(ulResult * 100) / 100;
+
+      if (!flags.json && !flags.simple) {
+        const uc = ratingColor("speed", results.upload);
+        console.log(
+          `  ${c.cyan}Upload    ${c.reset} ${uc}${c.bold}${formatSpeed(results.upload)}${c.reset} ${c.dim}Mbps${c.reset}  ${c.dim}(${ratingLabel("speed", results.upload)})${c.reset}`
+        );
+        console.log();
+      }
+    }
+  }
+
+  // ── Bufferbloat ───────────────────────────────────────────────
+  if (!flags.skip.has("bloat")) {
+    if (!flags.json && !flags.simple) startSpinner("Checking bufferbloat...");
+
+    const bloatResult = await runBufferbloat(base, signal, (phase, value) => {
+      if (!flags.json && !flags.simple) {
+        if (phase === "idle") {
+          stopSpinner();
+        }
+      }
+    });
+
+    stopSpinner();
+
+    if (bloatResult) {
+      results.bufferbloat = {
+        idleLatency: Math.round(bloatResult.idleLatency * 100) / 100,
+        loadedLatency: Math.round(bloatResult.loadedLatency * 100) / 100,
+        bloatMs: Math.round(bloatResult.bloatMs * 100) / 100,
+        grade: bloatResult.grade,
+      };
+
+      if (!flags.json && !flags.simple) {
+        const bc = bloatColor(bloatResult.grade);
+        console.log(
+          `  ${c.cyan}Bloat     ${c.reset} ${bc}${c.bold}Grade ${bloatResult.grade}${c.reset}  ${c.dim}(+${Math.round(bloatResult.bloatMs)}ms under load)${c.reset}`
+        );
+        console.log();
+      }
+    }
+  }
+
+  // ── Experience Scores ─────────────────────────────────────────
+  if (results.ping != null && results.download != null) {
+    const dl = results.download;
+    const ul = results.upload ?? 0;
+    const ping = results.ping;
+    const jitter = results.jitter ?? 0;
+
+    results.scores = {
+      video4k: scoreVideo4k(dl, ping, jitter),
+      videoCall: scoreVideoCall(dl, ul, ping, jitter),
+      gaming: scoreGaming(ping, jitter, dl),
+      web: scoreWeb(dl, ping),
+    };
+
+    if (!flags.json && !flags.simple) {
+      console.log(`  ${c.dim}${"─".repeat(48)}${c.reset}`);
+      console.log(`  ${c.bold}Experience Scores${c.reset}`);
+      console.log();
+
+      const scoreEntries = [
+        ["4K Video", results.scores.video4k],
+        ["Video Call", results.scores.videoCall],
+        ["Gaming", results.scores.gaming],
+        ["Web", results.scores.web],
+      ];
+
+      for (const [label, score] of scoreEntries) {
+        const sc = scoreColor(score);
+        const bar = scoreBar(score);
+        console.log(
+          `  ${label.padEnd(12)} ${sc}${bar}${c.reset} ${sc}${c.bold}${score}${c.reset}${c.dim}/100${c.reset}`
+        );
+      }
+      console.log();
+    }
+  }
+
+  // ── Results URL ───────────────────────────────────────────────
+  const resultsUrl = buildResultsUrl(results);
+  results.resultsUrl = resultsUrl;
+
+  // ── Output ────────────────────────────────────────────────────
+  if (flags.json) {
+    console.log(JSON.stringify(results, null, 2));
+  } else if (flags.simple) {
+    const parts = [];
+    if (results.ping != null) parts.push(`Ping: ${results.ping.toFixed(1)}ms`);
+    if (results.download != null) parts.push(`DL: ${formatSpeed(results.download)} Mbps`);
+    if (results.upload != null) parts.push(`UL: ${formatSpeed(results.upload)} Mbps`);
+    if (results.jitter != null) parts.push(`Jitter: ${results.jitter.toFixed(1)}ms`);
+    if (results.bufferbloat) parts.push(`Bloat: ${results.bufferbloat.grade}`);
+    console.log(parts.join(" | "));
+  } else {
+    // Show results URL
+    console.log(`  ${c.dim}Share results:${c.reset} ${c.cyan}${resultsUrl}${c.reset}`);
+    console.log();
+    console.log(`  ${c.dim}Powered by pong.com${c.reset}`);
+    console.log();
+  }
+}
+
+// ── Helpers ───────────────────────────────────────────────────────
+function formatSpeed(mbps) {
+  if (mbps >= 100) return mbps.toFixed(0);
+  if (mbps >= 10) return mbps.toFixed(1);
+  return mbps.toFixed(2);
+}
+
+function scoreBar(score) {
+  const width = 20;
+  const filled = Math.round((score / 100) * width);
+  const empty = width - filled;
+  return "█".repeat(filled) + "░".repeat(empty);
+}
+
+function buildResultsUrl(results) {
+  const params = new URLSearchParams();
+  params.set("src", "cli");
+  if (results.ping != null) params.set("p", results.ping.toFixed(1));
+  if (results.jitter != null) params.set("j", results.jitter.toFixed(1));
+  if (results.download != null) params.set("dl", results.download.toFixed(1));
+  if (results.upload != null) params.set("ul", results.upload.toFixed(1));
+  if (results.bufferbloat) params.set("bb", results.bufferbloat.grade);
+  if (results.server.code !== "auto") params.set("srv", results.server.code);
+  return `https://pong.com/results?${params.toString()}`;
+}
+
+// ── Run ───────────────────────────────────────────────────────────
+main().catch((err) => {
+  stopSpinner();
+  if (err.name === "AbortError") {
+    process.exit(0);
+  }
+  console.error(`\n${c.red}Error:${c.reset} ${err.message}\n`);
+  process.exit(1);
+});

package/lib/speedtest.js

@@ -0,0 +1,274 @@
+// ═══════════════════════════════════════════════════════════════════
+// Speed test core (zero dependencies, Node 18+ built-in fetch)
+// Mirrors the logic from the Chrome extension popup.js
+// ═══════════════════════════════════════════════════════════════════
+
+import { progressBar, stopSpinner } from "./ui.js";
+
+// ── Servers ──────────────────────────────────────────────────────
+export const SERVERS = {
+  auto: { code: "auto", name: "Auto (Cloudflare Edge)", url: "https://speed.pong.com" },
+  ewr: { code: "ewr", name: "Newark, US", url: "https://speed-ewr.pong.com" },
+  lax: { code: "lax", name: "Los Angeles, US", url: "https://speed-lax.pong.com" },
+  yyz: { code: "yyz", name: "Toronto, CA", url: "https://speed-yyz.pong.com" },
+  lhr: { code: "lhr", name: "London, GB", url: "https://speed-lhr.pong.com" },
+  fra: { code: "fra", name: "Frankfurt, DE", url: "https://speed-fra.pong.com" },
+  nrt: { code: "nrt", name: "Tokyo, JP", url: "https://speed-nrt.pong.com" },
+  sin: { code: "sin", name: "Singapore, SG", url: "https://speed-sin.pong.com" },
+  bom: { code: "bom", name: "Mumbai, IN", url: "https://speed-bom.pong.com" },
+  syd: { code: "syd", name: "Sydney, AU", url: "https://speed-syd.pong.com" },
+  gru: { code: "gru", name: "Sao Paulo, BR", url: "https://speed-gru.pong.com" },
+};
+
+// ── Warm up connections ──────────────────────────────────────────
+async function warmUp(base, signal, count = 3) {
+  const fetches = Array.from({ length: count }, () =>
+    fetch(`${base}/ping?t=${Date.now()}&warm=1`, { signal }).catch(() => null)
+  );
+  await Promise.all(fetches);
+}
+
+// ── Ping ─────────────────────────────────────────────────────────
+export async function runPing(base, signal, onProgress) {
+  await warmUp(base, signal, 1);
+  const pings = [];
+
+  for (let i = 0; i < 20; i++) {
+    if (signal.aborted) return null;
+    const start = performance.now();
+    try {
+      await fetch(`${base}/ping?t=${Date.now()}`, { signal });
+      const ms = performance.now() - start;
+      pings.push(ms);
+      if (onProgress) onProgress(ms, i + 1, 20);
+    } catch {
+      if (signal.aborted) return null;
+    }
+  }
+
+  if (pings.length === 0) return null;
+
+  const sorted = [...pings].sort((a, b) => a - b);
+  const trim = Math.max(1, Math.floor(sorted.length * 0.1));
+  const trimmed = sorted.slice(trim, sorted.length - trim);
+  const avg = trimmed.reduce((a, b) => a + b, 0) / trimmed.length;
+  const jitter = trimmed.reduce((s, p) => s + Math.abs(p - avg), 0) / trimmed.length;
+
+  return { ping: avg, jitter, min: sorted[0], max: sorted[sorted.length - 1] };
+}
+
+// ── Download ─────────────────────────────────────────────────────
+export async function runDownload(base, signal, onProgress) {
+  await warmUp(base, signal, 8);
+
+  const phases = [
+    { chunkSize: 4_000_000, streams: 6 },
+    { chunkSize: 16_000_000, streams: 8 },
+    { chunkSize: 25_000_000, streams: 8 },
+  ];
+
+  let totalBytes = 0;
+  const globalStart = performance.now();
+  let lastReport = globalStart;
+
+  for (const phase of phases) {
+    if (signal.aborted) return null;
+
+    const downloads = Array.from({ length: phase.streams }, async () => {
+      if (signal.aborted) return;
+      try {
+        const res = await fetch(
+          `${base}/download?size=${phase.chunkSize}&t=${Date.now()}`,
+          { signal }
+        );
+        const reader = res.body?.getReader();
+        if (!reader) return;
+
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done || signal.aborted) break;
+          totalBytes += value.byteLength;
+
+          const now = performance.now();
+          if (now - lastReport > 150) {
+            const elapsed = (now - globalStart) / 1000;
+            const mbps = (totalBytes * 8) / (elapsed * 1_000_000);
+            if (onProgress) onProgress(mbps);
+            lastReport = now;
+          }
+        }
+      } catch {
+        // stream error
+      }
+    });
+
+    await Promise.all(downloads);
+  }
+
+  const totalTime = (performance.now() - globalStart) / 1000;
+  return totalBytes > 0 ? (totalBytes * 8) / (totalTime * 1_000_000) : null;
+}
+
+// ── Upload ───────────────────────────────────────────────────────
+export async function runUpload(base, signal, onProgress) {
+  const UPLOAD_DURATION = 10_000;
+  const CHUNK_SIZE = 4_000_000;
+  const UPLOAD_STREAMS = 6;
+  const uploadData = new Uint8Array(CHUNK_SIZE);
+
+  let totalBytes = 0;
+  const globalStart = performance.now();
+  let lastReport = globalStart;
+  let running = true;
+
+  const timer = setTimeout(() => { running = false; }, UPLOAD_DURATION);
+
+  const workers = Array.from({ length: UPLOAD_STREAMS }, async () => {
+    while (running && !signal.aborted) {
+      try {
+        await fetch(`${base}/upload?t=${Date.now()}`, {
+          method: "POST",
+          body: uploadData,
+          signal,
+        });
+        totalBytes += CHUNK_SIZE;
+
+        const now = performance.now();
+        if (now - lastReport > 150) {
+          const elapsed = (now - globalStart) / 1000;
+          const mbps = (totalBytes * 8) / (elapsed * 1_000_000);
+          if (onProgress) onProgress(mbps);
+          lastReport = now;
+        }
+      } catch {
+        if (signal.aborted) break;
+        await new Promise((r) => setTimeout(r, 100));
+      }
+    }
+  });
+
+  await Promise.all(workers);
+  clearTimeout(timer);
+
+  const totalTime = (performance.now() - globalStart) / 1000;
+  return totalBytes > 0 ? (totalBytes * 8) / (totalTime * 1_000_000) : null;
+}
+
+// ── Bufferbloat ──────────────────────────────────────────────────
+export async function runBufferbloat(base, signal, onProgress) {
+  // Measure idle latency
+  const idlePings = [];
+  for (let i = 0; i < 5; i++) {
+    if (signal.aborted) return null;
+    const start = performance.now();
+    try {
+      await fetch(`${base}/ping?t=${Date.now()}`, { signal });
+      idlePings.push(performance.now() - start);
+    } catch {
+      if (signal.aborted) return null;
+    }
+  }
+  if (idlePings.length === 0) return null;
+  const idleLatency = idlePings.sort((a, b) => a - b)[Math.floor(idlePings.length / 2)];
+
+  if (onProgress) onProgress("idle", idleLatency);
+
+  // Start background load
+  const loadCtrl = new AbortController();
+  signal.addEventListener("abort", () => loadCtrl.abort());
+
+  for (let i = 0; i < 4; i++) {
+    (async () => {
+      try {
+        const res = await fetch(`${base}/download?size=32000000&t=${Date.now()}-${i}`, {
+          signal: loadCtrl.signal,
+        });
+        const reader = res.body?.getReader();
+        if (!reader) return;
+        while (true) {
+          const { done } = await reader.read();
+          if (done) break;
+        }
+      } catch { /* expected abort */ }
+    })();
+  }
+
+  await new Promise((r) => setTimeout(r, 1500));
+
+  // Measure loaded latency
+  const loadedPings = [];
+  for (let i = 0; i < 10; i++) {
+    if (signal.aborted) { loadCtrl.abort(); return null; }
+    const start = performance.now();
+    try {
+      await fetch(`${base}/ping?t=${Date.now()}-load`, { signal });
+      const ms = performance.now() - start;
+      loadedPings.push(ms);
+      if (onProgress) onProgress("loaded", ms, i + 1, 10);
+    } catch {
+      if (signal.aborted) { loadCtrl.abort(); return null; }
+    }
+  }
+
+  loadCtrl.abort();
+
+  if (loadedPings.length === 0) return null;
+  const loadedLatency = loadedPings.sort((a, b) => a - b)[Math.floor(loadedPings.length / 2)];
+  const bloat = Math.max(0, loadedLatency - idleLatency);
+
+  let grade;
+  if (bloat <= 5) grade = "A";
+  else if (bloat <= 30) grade = "B";
+  else if (bloat <= 60) grade = "C";
+  else if (bloat <= 200) grade = "D";
+  else grade = "F";
+
+  return { idleLatency, loadedLatency, bloatMs: bloat, grade };
+}
+
+// ── Experience Scores (matches pong.com scoring) ─────────────────
+function clamp(v, min, max) { return Math.max(min, Math.min(max, v)); }
+
+export function scoreVideo4k(dl, ping, jitter) {
+  let s = 0;
+  if (dl >= 50) s += 60; else if (dl >= 25) s += 40 + ((dl - 25) / 25) * 20;
+  else if (dl >= 10) s += 15 + ((dl - 10) / 15) * 25; else s += (dl / 10) * 15;
+  if (ping <= 30) s += 25; else if (ping <= 60) s += 15 + ((60 - ping) / 30) * 10;
+  else s += Math.max(0, 15 - (ping - 60) / 10);
+  if (jitter <= 5) s += 15; else if (jitter <= 15) s += 8 + ((15 - jitter) / 10) * 7;
+  else s += Math.max(0, 8 - (jitter - 15) / 5);
+  return clamp(Math.round(s), 0, 100);
+}
+
+export function scoreVideoCall(dl, ul, ping, jitter) {
+  const min = Math.min(dl, ul);
+  let s = 0;
+  if (min >= 10) s += 35; else if (min >= 5) s += 20 + ((min - 5) / 5) * 15;
+  else if (min >= 2) s += 8 + ((min - 2) / 3) * 12; else s += (min / 2) * 8;
+  if (ping <= 30) s += 30; else if (ping <= 60) s += 18 + ((60 - ping) / 30) * 12;
+  else if (ping <= 150) s += 5 + ((150 - ping) / 90) * 13; else s += Math.max(0, 5 - (ping - 150) / 50);
+  if (jitter <= 5) s += 20; else if (jitter <= 15) s += 10 + ((15 - jitter) / 10) * 10;
+  else if (jitter <= 30) s += 3 + ((30 - jitter) / 15) * 7; else s += Math.max(0, 3 - (jitter - 30) / 10);
+  if (ul >= dl * 0.5) s += 15; else s += (ul / (dl * 0.5)) * 15;
+  return clamp(Math.round(s), 0, 100);
+}
+
+export function scoreGaming(ping, jitter, dl) {
+  let s = 0;
+  if (ping <= 15) s += 45; else if (ping <= 30) s += 30 + ((30 - ping) / 15) * 15;
+  else if (ping <= 60) s += 15 + ((60 - ping) / 30) * 15; else s += Math.max(0, 15 - (ping - 60) / 10);
+  if (jitter <= 3) s += 30; else if (jitter <= 10) s += 18 + ((10 - jitter) / 7) * 12;
+  else if (jitter <= 20) s += 8 + ((20 - jitter) / 10) * 10; else s += Math.max(0, 8 - (jitter - 20) / 5);
+  if (dl >= 25) s += 25; else if (dl >= 10) s += 15 + ((dl - 10) / 15) * 10;
+  else s += (dl / 10) * 15;
+  return clamp(Math.round(s), 0, 100);
+}
+
+export function scoreWeb(dl, ping) {
+  let s = 0;
+  if (dl >= 50) s += 50; else if (dl >= 10) s += 25 + ((dl - 10) / 40) * 25;
+  else s += (dl / 10) * 25;
+  if (ping <= 20) s += 50; else if (ping <= 50) s += 30 + ((50 - ping) / 30) * 20;
+  else if (ping <= 100) s += 15 + ((100 - ping) / 50) * 15; else s += Math.max(0, 15 - (ping - 100) / 20);
+  return clamp(Math.round(s), 0, 100);
+}

package/lib/ui.js

@@ -0,0 +1,131 @@
+// ═══════════════════════════════════════════════════════════════════
+// Terminal UI helpers (zero dependencies, pure ANSI)
+// ═══════════════════════════════════════════════════════════════════
+
+const isColorSupported =
+  process.env.FORCE_COLOR !== "0" &&
+  (process.env.FORCE_COLOR || process.stdout.isTTY);
+
+const c = isColorSupported
+  ? {
+      reset: "\x1b[0m",
+      bold: "\x1b[1m",
+      dim: "\x1b[2m",
+      cyan: "\x1b[36m",
+      green: "\x1b[32m",
+      yellow: "\x1b[33m",
+      red: "\x1b[31m",
+      white: "\x1b[97m",
+      gray: "\x1b[90m",
+      bgCyan: "\x1b[46m",
+      bgGreen: "\x1b[42m",
+      bgYellow: "\x1b[43m",
+      bgRed: "\x1b[41m",
+      black: "\x1b[30m",
+      hide: "\x1b[?25l",
+      show: "\x1b[?25h",
+      clearLine: "\x1b[2K",
+      up: "\x1b[1A",
+    }
+  : Object.fromEntries(
+      [
+        "reset","bold","dim","cyan","green","yellow","red","white",
+        "gray","bgCyan","bgGreen","bgYellow","bgRed","black",
+        "hide","show","clearLine","up",
+      ].map((k) => [k, ""])
+    );
+
+export { c };
+
+// ── Spinner ──────────────────────────────────────────────────────
+const SPINNER_FRAMES = ["   ", ".  ", ".. ", "..."];
+let spinnerInterval = null;
+let spinnerFrame = 0;
+
+export function startSpinner(text) {
+  process.stdout.write(c.hide);
+  spinnerFrame = 0;
+  spinnerInterval = setInterval(() => {
+    spinnerFrame = (spinnerFrame + 1) % SPINNER_FRAMES.length;
+    process.stdout.write(
+      `\r${c.clearLine}  ${c.cyan}${SPINNER_FRAMES[spinnerFrame]}${c.reset} ${c.dim}${text}${c.reset}`
+    );
+  }, 250);
+}
+
+export function stopSpinner() {
+  if (spinnerInterval) {
+    clearInterval(spinnerInterval);
+    spinnerInterval = null;
+  }
+  process.stdout.write(`\r${c.clearLine}${c.show}`);
+}
+
+// ── Progress bar ─────────────────────────────────────────────────
+export function progressBar(label, value, unit, maxVal) {
+  const barWidth = 30;
+  const pct = Math.min(value / maxVal, 1);
+  const filled = Math.round(barWidth * pct);
+  const empty = barWidth - filled;
+
+  const bar = `${"█".repeat(filled)}${"░".repeat(empty)}`;
+  const valStr =
+    value >= 100 ? value.toFixed(0) : value >= 10 ? value.toFixed(1) : value.toFixed(2);
+
+  process.stdout.write(
+    `\r${c.clearLine}  ${c.cyan}${label.padEnd(10)}${c.reset} ${c.dim}${bar}${c.reset} ${c.bold}${c.white}${valStr}${c.reset} ${c.dim}${unit}${c.reset}`
+  );
+}
+
+// ── Rating helpers ───────────────────────────────────────────────
+export function ratingColor(type, value) {
+  if (type === "ping" || type === "jitter") {
+    if (value <= 10) return c.green;
+    if (value <= 30) return c.cyan;
+    if (value <= 60) return c.yellow;
+    return c.red;
+  }
+  if (value >= 100) return c.green;
+  if (value >= 25) return c.cyan;
+  if (value >= 10) return c.yellow;
+  return c.red;
+}
+
+export function ratingLabel(type, value) {
+  if (type === "ping" || type === "jitter") {
+    if (value <= 10) return "Excellent";
+    if (value <= 30) return "Good";
+    if (value <= 60) return "Fair";
+    return "Poor";
+  }
+  if (value >= 100) return "Excellent";
+  if (value >= 25) return "Good";
+  if (value >= 10) return "Fair";
+  return "Poor";
+}
+
+export function bloatColor(grade) {
+  if (grade <= "B") return c.green;
+  if (grade === "C") return c.yellow;
+  return c.red;
+}
+
+export function scoreColor(score) {
+  if (score >= 80) return c.green;
+  if (score >= 60) return c.cyan;
+  if (score >= 40) return c.yellow;
+  return c.red;
+}
+
+// ── Box drawing ──────────────────────────────────────────────────
+export function box(lines, width = 52) {
+  const top = `  ${c.dim}╭${"─".repeat(width)}╮${c.reset}`;
+  const bot = `  ${c.dim}╰${"─".repeat(width)}╯${c.reset}`;
+  const rows = lines.map((l) => {
+    // Strip ANSI for length calculation
+    const stripped = l.replace(/\x1b\[[0-9;]*m/g, "");
+    const pad = Math.max(0, width - 2 - stripped.length);
+    return `  ${c.dim}│${c.reset} ${l}${" ".repeat(pad)} ${c.dim}│${c.reset}`;
+  });
+  return [top, ...rows, bot].join("\n");
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "pongspeedtest",
+  "version": "1.0.0",
+  "description": "Fast internet speed test from your terminal. Ping, download, upload, jitter & bufferbloat.",
+  "bin": {
+    "pong": "bin/pong.js"
+  },
+  "type": "module",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "keywords": [
+    "speedtest",
+    "speed-test",
+    "internet",
+    "bandwidth",
+    "ping",
+    "download",
+    "upload",
+    "jitter",
+    "bufferbloat",
+    "network",
+    "cli",
+    "pong"
+  ],
+  "author": "pong.com",
+  "license": "MIT",
+  "homepage": "https://pong.com",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pongcom/cli.git"
+  }
+}