free-coding-models 0.1.84 → 0.1.86

package/src/render-table.js

@@ -43,29 +43,29 @@ import { calculateViewport, sortResultsWithPinnedFavorites, renderProxyStatusLin
 const require = createRequire(import.meta.url)
 const { version: LOCAL_VERSION } = require('../package.json')
 
-// 📖 Provider column palette: keep all Origins in the same visual family
-// 📖 (blue/cyan tones) while making each provider easy to distinguish at a glance.
+// 📖 Provider column palette: soft pastel rainbow so each provider stays easy
+// 📖 to spot without turning the table into a harsh neon wall.
 const PROVIDER_COLOR = {
-  nvidia: [120, 205, 255],
-  groq: [95, 185, 255],
-  cerebras: [70, 165, 255],
-  sambanova: [45, 145, 245],
-  openrouter: [135, 220, 255],
-  huggingface: [110, 190, 235],
-  replicate: [85, 175, 230],
-  deepinfra: [60, 160, 225],
-  fireworks: [125, 215, 245],
-  codestral: [100, 180, 240],
-  hyperbolic: [75, 170, 240],
-  scaleway: [55, 150, 235],
-  googleai: [130, 210, 255],
-  siliconflow: [90, 195, 245],
-  together: [65, 155, 245],
-  cloudflare: [115, 200, 240],
-  perplexity: [140, 225, 255],
-  qwen: [80, 185, 235],
-  zai: [50, 140, 225],
-  iflow: [145, 230, 255],
+  nvidia: [178, 235, 190],
+  groq: [255, 204, 188],
+  cerebras: [179, 229, 252],
+  sambanova: [255, 224, 178],
+  openrouter: [225, 190, 231],
+  huggingface: [255, 245, 157],
+  replicate: [187, 222, 251],
+  deepinfra: [178, 223, 219],
+  fireworks: [255, 205, 210],
+  codestral: [248, 187, 208],
+  hyperbolic: [200, 230, 201],
+  scaleway: [129, 212, 250],
+  googleai: [187, 222, 251],
+  siliconflow: [178, 235, 242],
+  together: [197, 225, 165],
+  cloudflare: [255, 204, 128],
+  perplexity: [159, 234, 201],
+  qwen: [255, 224, 130],
+  zai: [174, 213, 255],
+  iflow: [220, 231, 117],
 }
 
 // 📖 Active proxy reference for footer status line (set by bin/free-coding-models.js).
@@ -77,7 +77,7 @@ export function setActiveProxy(proxyInstance) {
 }
 
 // ─── renderTable: mode param controls footer hint text (opencode vs openclaw) ─────────
-export function renderTable(results, pendingPings, frame, cursor = null, sortColumn = 'avg', sortDirection = 'asc', pingInterval = PING_INTERVAL, lastPingTime = Date.now(), mode = 'opencode', tierFilterMode = 0, scrollOffset = 0, terminalRows = 0, originFilterMode = 0, activeProfile = null, profileSaveMode = false, profileSaveBuffer = '', proxyStartupStatus = null) {
+export function renderTable(results, pendingPings, frame, cursor = null, sortColumn = 'avg', sortDirection = 'asc', pingInterval = PING_INTERVAL, lastPingTime = Date.now(), mode = 'opencode', tierFilterMode = 0, scrollOffset = 0, terminalRows = 0, terminalCols = 0, originFilterMode = 0, activeProfile = null, profileSaveMode = false, profileSaveBuffer = '', proxyStartupStatus = null, pingMode = 'normal', pingModeSource = 'auto', hideUnconfiguredModels = false) {
   // 📖 Filter out hidden models for display
   const visibleResults = results.filter(r => !r.hidden)
 
@@ -85,31 +85,48 @@ export function renderTable(results, pendingPings, frame, cursor = null, sortCol
   const down    = visibleResults.filter(r => r.status === 'down').length
   const timeout = visibleResults.filter(r => r.status === 'timeout').length
   const pending = visibleResults.filter(r => r.status === 'pending').length
+  const totalVisible = visibleResults.length
+  const completedPings = Math.max(0, totalVisible - pending)
 
   // 📖 Calculate seconds until next ping
   const timeSinceLastPing = Date.now() - lastPingTime
   const timeUntilNextPing = Math.max(0, pingInterval - timeSinceLastPing)
-  const secondsUntilNext = Math.ceil(timeUntilNextPing / 1000)
+  const secondsUntilNext = timeUntilNextPing / 1000
+  const secondsUntilNextLabel = secondsUntilNext.toFixed(1)
 
-  const phase = pending > 0
-    ? chalk.dim(`discovering — ${pending} remaining…`)
-    : pendingPings > 0
-      ? chalk.dim(`pinging — ${pendingPings} in flight…`)
-      : chalk.dim(`next ping ${secondsUntilNext}s`)
-
-  // 📖 Mode badge shown in header so user knows what Enter will do
-  // 📖 Now includes key hint for mode toggle
+  const intervalSec = Math.round(pingInterval / 1000)
+  const pingModeMeta = {
+    speed: { label: 'fast', color: chalk.bold.rgb(255, 210, 80) },
+    normal: { label: 'normal', color: chalk.bold.rgb(120, 210, 255) },
+    slow: { label: 'slow', color: chalk.bold.rgb(255, 170, 90) },
+    forced: { label: 'forced', color: chalk.bold.rgb(255, 120, 120) },
+  }
+  const activePingMode = pingModeMeta[pingMode] ?? pingModeMeta.normal
+  const pingProgressText = `${completedPings}/${totalVisible}`
+  const nextCountdownColor = secondsUntilNext > 8
+    ? chalk.red.bold
+    : secondsUntilNext >= 4
+      ? chalk.yellow.bold
+      : secondsUntilNext < 1
+        ? chalk.greenBright.bold
+        : chalk.green.bold
+  const pingControlBadge =
+    activePingMode.color(' [ ') +
+    chalk.yellow.bold('W') +
+    activePingMode.color(` Ping Interval : ${intervalSec}s (${activePingMode.label}) - ${pingProgressText} - next : `) +
+    nextCountdownColor(`${secondsUntilNextLabel}s`) +
+    activePingMode.color(' ]')
+
+  // 📖 Tool badge keeps the active launch target visible in the header, so the
+  // 📖 footer no longer needs a redundant Enter action or mode toggle reminder.
   let modeBadge
   if (mode === 'openclaw') {
-    modeBadge = chalk.bold.rgb(255, 100, 50)(' [🦞 OpenClaw]')
+    modeBadge = chalk.bold.rgb(255, 100, 50)(' [ ') + chalk.yellow.bold('Z') + chalk.bold.rgb(255, 100, 50)(' Tool : OpenClaw ]')
   } else if (mode === 'opencode-desktop') {
-    modeBadge = chalk.bold.rgb(0, 200, 255)(' [🖥  Desktop]')
+    modeBadge = chalk.bold.rgb(0, 200, 255)(' [ ') + chalk.yellow.bold('Z') + chalk.bold.rgb(0, 200, 255)(' Tool : OpenCode Desktop ]')
   } else {
-    modeBadge = chalk.bold.rgb(0, 200, 255)(' [💻 CLI]')
+    modeBadge = chalk.bold.rgb(0, 200, 255)(' [ ') + chalk.yellow.bold('Z') + chalk.bold.rgb(0, 200, 255)(' Tool : OpenCode CLI ]')
   }
-  
-  // 📖 Add mode toggle hint
-  const modeHint = chalk.dim.yellow(' (Z to toggle)')
 
   // 📖 Tier filter badge shown when filtering is active (shows exact tier name)
   const TIER_CYCLE_NAMES = [null, 'S+', 'S', 'A+', 'A', 'A-', 'B+', 'B', 'C']
@@ -155,16 +172,29 @@ export function renderTable(results, pendingPings, frame, cursor = null, sortCol
   const W_UPTIME = 6
   const W_TOKENS = 7
   const W_USAGE = 7
+  const MIN_TABLE_WIDTH = 166
+
+  if (terminalCols > 0 && terminalCols < MIN_TABLE_WIDTH) {
+    const lines = []
+    const blankLines = Math.max(0, Math.floor(((terminalRows || 24) - 3) / 2))
+    const warning = 'Please maximize your terminal for optimal use. The current terminal width is too small for the full table.'
+    const padLeft = Math.max(0, Math.floor((terminalCols - warning.length) / 2))
+    for (let i = 0; i < blankLines; i++) lines.push('')
+    lines.push(' '.repeat(padLeft) + chalk.red.bold(warning))
+    while (terminalRows > 0 && lines.length < terminalRows) lines.push('')
+    const EL = '\x1b[K'
+    return lines.map(line => line + EL).join('\n')
+  }
 
   // 📖 Sort models using the shared helper
   const sorted = sortResultsWithPinnedFavorites(visibleResults, sortColumn, sortDirection)
 
   const lines = [
-    `  ${chalk.greenBright.bold('✅ FCM')}${modeBadge}${modeHint}${tierBadge}${originBadge}${profileBadge}   ` +
+    `  ${chalk.greenBright.bold(`✅ Free-Coding-Models v${LOCAL_VERSION}`)}${modeBadge}${pingControlBadge}${tierBadge}${originBadge}${profileBadge}${chalk.reset('')}   ` +
       chalk.greenBright(`✅ ${up}`) + chalk.dim(' up  ') +
       chalk.yellow(`⏳ ${timeout}`) + chalk.dim(' timeout  ') +
       chalk.red(`❌ ${down}`) + chalk.dim(' down  ') +
-      phase,
+      '',
     '',
   ]
 
@@ -259,6 +289,16 @@ export function renderTable(results, pendingPings, frame, cursor = null, sortCol
     chalk.dim('─'.repeat(W_USAGE))
   )
 
+  if (sorted.length === 0) {
+    lines.push('')
+    if (hideUnconfiguredModels) {
+      lines.push(`  ${chalk.redBright.bold('Press P to configure your API key.')}`)
+      lines.push(`  ${chalk.dim('No configured provider currently exposes visible models in the table.')}`)
+    } else {
+      lines.push(`  ${chalk.yellow.bold('No models match the current filters.')}`)
+    }
+  }
+
   // 📖 Viewport clipping: only render models that fit on screen
   const vp = calculateViewport(terminalRows, scrollOffset, sorted.length)
 
@@ -286,6 +326,7 @@ export function renderTable(results, pendingPings, frame, cursor = null, sortCol
     const prefixDisplayWidth = 2
     const nameWidth = Math.max(0, W_MODEL - prefixDisplayWidth)
     const name = favoritePrefix + r.label.slice(0, nameWidth).padEnd(nameWidth)
+    const modelColor = chalk.rgb(...providerRgb)
     const sweScore = r.sweScore ?? '—'
     // 📖 SWE% colorized on the same gradient as Tier:
     //   ≥70% bright neon green (S+), ≥60% green (S), ≥50% yellow-green (A+),
@@ -315,22 +356,30 @@ export function renderTable(results, pendingPings, frame, cursor = null, sortCol
       ? chalk.cyan(ctxRaw.padEnd(W_CTX))
       : chalk.dim(ctxRaw.padEnd(W_CTX))
 
+    // 📖 Keep the row-local spinner small and inline so users can still read the last measured latency.
+    const buildLatestPingDisplay = (value) => {
+      const spinner = r.isPinging ? ` ${FRAMES[frame % FRAMES.length]}` : ''
+      return `${value}${spinner}`.padEnd(W_PING)
+    }
+
     // 📖 Latest ping - pings are objects: { ms, code }
     // 📖 Show response time for 200 (success) and 401 (no-auth but server is reachable)
     const latestPing = r.pings.length > 0 ? r.pings[r.pings.length - 1] : null
     let pingCell
     if (!latestPing) {
-      pingCell = chalk.dim('———'.padEnd(W_PING))
+      const placeholder = r.isPinging ? buildLatestPingDisplay('———') : '———'.padEnd(W_PING)
+      pingCell = chalk.dim(placeholder)
     } else if (latestPing.code === '200') {
       // 📖 Success - show response time
-      const str = String(latestPing.ms).padEnd(W_PING)
+      const str = buildLatestPingDisplay(String(latestPing.ms))
       pingCell = latestPing.ms < 500 ? chalk.greenBright(str) : latestPing.ms < 1500 ? chalk.yellow(str) : chalk.red(str)
     } else if (latestPing.code === '401') {
       // 📖 401 = no API key but server IS reachable — still show latency in dim
-      pingCell = chalk.dim(String(latestPing.ms).padEnd(W_PING))
+      pingCell = chalk.dim(buildLatestPingDisplay(String(latestPing.ms)))
     } else {
       // 📖 Error or timeout - show "———" (error code is already in Status column)
-      pingCell = chalk.dim('———'.padEnd(W_PING))
+      const placeholder = r.isPinging ? buildLatestPingDisplay('———') : '———'.padEnd(W_PING)
+      pingCell = chalk.dim(placeholder)
     }
 
     // 📖 Avg ping (just number, no "ms")
@@ -465,10 +514,11 @@ export function renderTable(results, pendingPings, frame, cursor = null, sortCol
       uptimeCell = chalk.red(uptimeStr.padEnd(W_UPTIME))
     }
 
-    // 📖 When cursor is on this row, render Model and Provider in bright white for readability
-    const nameCell = isCursor ? chalk.white.bold(favoritePrefix + r.label.slice(0, nameWidth).padEnd(nameWidth)) : name
+    // 📖 Model text now mirrors the provider hue so provider affinity is visible
+    // 📖 even before the eye reaches the Provider column.
+    const nameCell = isCursor ? modelColor.bold(name) : modelColor(name)
     const sourceCursorText = providerName.padEnd(W_SOURCE)
-    const sourceCell = isCursor ? chalk.white.bold(sourceCursorText) : source
+    const sourceCell = isCursor ? chalk.rgb(...providerRgb).bold(sourceCursorText) : source
 
     // 📖 Usage column — provider-scoped remaining quota when measurable,
     // 📖 otherwise a green dot to show "usable but not meaningfully quantifiable".
@@ -502,12 +552,12 @@ export function renderTable(results, pendingPings, frame, cursor = null, sortCol
     const row = '  ' + num + '  ' + tier + '  ' + sweCell + '  ' + ctxCell + '  ' + nameCell + '  ' + sourceCell + '  ' + pingCell + '  ' + avgCell + '  ' + status + '  ' + speedCell + '  ' + stabCell + '  ' + uptimeCell + '  ' + tokensCell + '  ' + usageCell
 
     if (isCursor) {
-      lines.push(chalk.bgRgb(50, 0, 60)(row))
+      lines.push(chalk.bgRgb(155, 55, 135)(row))
     } else if (r.isRecommended) {
       // 📖 Medium green background for recommended models (distinguishable from favorites)
       lines.push(chalk.bgRgb(15, 40, 15)(row))
     } else if (r.isFavorite) {
-      lines.push(chalk.bgRgb(35, 20, 0)(row))
+      lines.push(chalk.bgRgb(88, 64, 10)(row))
     } else {
       lines.push(row)
     }
@@ -523,18 +573,13 @@ export function renderTable(results, pendingPings, frame, cursor = null, sortCol
    } else {
      lines.push('')
    }
-  const intervalSec = Math.round(pingInterval / 1000)
-
-  // 📖 Footer hints adapt based on active mode
-  const actionHint = mode === 'openclaw'
-    ? chalk.rgb(255, 100, 50)('Enter→SetOpenClaw')
-    : mode === 'opencode-desktop'
-      ? chalk.rgb(0, 200, 255)('Enter→OpenDesktop')
-      : chalk.rgb(0, 200, 255)('Enter→OpenCode')
-  // 📖 Line 1: core navigation + sorting shortcuts
-  lines.push(chalk.dim(`  ↑↓ Navigate  •  `) + actionHint + chalk.dim(`  •  `) + chalk.yellow('F') + chalk.dim(` Favorite  •  R/Y/O/M/L/A/S/C/H/V/B/U/`) + chalk.yellow('G') + chalk.dim(` Sort  •  `) + chalk.yellow('T') + chalk.dim(` Tier  •  `) + chalk.yellow('D') + chalk.dim(` Provider  •  W↓/=↑ (${intervalSec}s)  •  `) + chalk.rgb(255, 100, 50).bold('Z') + chalk.dim(` Mode  •  `) + chalk.yellow('X') + chalk.dim(` Logs  •  `) + chalk.yellow('P') + chalk.dim(` Settings  •  `) + chalk.rgb(0, 255, 80).bold('K') + chalk.dim(` Help`))
+  // 📖 Footer hints keep only navigation and secondary actions now that the
+  // 📖 active tool target is already visible in the header badge.
+  const hotkey = (keyLabel, text) => chalk.yellow(keyLabel) + chalk.dim(text)
+  // 📖 Line 1: core navigation + filtering shortcuts
+  lines.push(chalk.dim(`  ↑↓ Navigate  •  `) + hotkey('F', ' Toggle Favorite') + chalk.dim(`  •  `) + hotkey('T', ' Tier') + chalk.dim(`  •  `) + hotkey('D', ' Provider') + chalk.dim(`  •  `) + hotkey('E', ' Configured Only') + chalk.dim(`  •  `) + hotkey('X', ' Token Logs') + chalk.dim(`  •  `) + hotkey('P', ' Settings') + chalk.dim(`  •  `) + hotkey('K', ' Help'))
   // 📖 Line 2: profiles, recommend, feature request, bug report, and extended hints — gives visibility to less-obvious features
-  lines.push(chalk.dim(`  `) + chalk.rgb(200, 150, 255).bold('⇧P') + chalk.dim(` Cycle profile  •  `) + chalk.rgb(200, 150, 255).bold('⇧S') + chalk.dim(` Save profile  •  `) + chalk.rgb(0, 200, 180).bold('Q') + chalk.dim(` Smart Recommend  •  `) + chalk.rgb(57, 255, 20).bold('J') + chalk.dim(` Request feature  •  `) + chalk.rgb(255, 87, 51).bold('I') + chalk.dim(` Report bug  •  `) + chalk.yellow('Esc') + chalk.dim(` Close overlay`))
+  lines.push(chalk.dim(`  `) + hotkey('⇧P', ' Cycle profile') + chalk.dim(`  •  `) + hotkey('⇧S', ' Save profile') + chalk.dim(`  •  `) + hotkey('Q', ' Smart Recommend') + chalk.dim(`  •  `) + hotkey('J', ' Request feature') + chalk.dim(`  •  `) + hotkey('I', ' Report bug'))
   // 📖 Proxy status line — always rendered with explicit state (starting/running/failed/stopped)
   lines.push(renderProxyStatusLine(proxyStartupStatus, activeProxyRef))
   lines.push(
@@ -551,8 +596,6 @@ export function renderTable(results, pendingPings, frame, cursor = null, sortCol
     chalk.dim(' → ') +
     chalk.rgb(200, 150, 255)('https://discord.gg/5MbTnDC3Md') +
     chalk.dim('  •  ') +
-    chalk.dim(`v${LOCAL_VERSION}`) +
-    chalk.dim('  •  ') +
     chalk.dim('Ctrl+C Exit')
   )
 

package/src/utils.js

@@ -74,18 +74,23 @@ export const TIER_LETTER_MAP = {
 
 // ─── Core Logic Functions ────────────────────────────────────────────────────
 
-// 📖 getAvg: Calculate average latency from ONLY successful pings (HTTP 200).
-// 📖 Failed pings (timeouts, 429s, 500s) are excluded to avoid skewing the average.
-// 📖 Returns Infinity when no successful pings exist — this sorts "unknown" models to the bottom.
+// 📖 measureablePingCodes: HTTP codes that still give us a real round-trip latency sample.
+// 📖 200 = normal success, 401 = no key / bad key but the provider endpoint is reachable.
+const measurablePingCodes = new Set(['200', '401'])
+
+// 📖 getAvg: Calculate average latency from pings that produced a real latency sample.
+// 📖 HTTP 200 and 401 both count because a 401 still proves the endpoint responded in X ms.
+// 📖 Timeouts and server failures are excluded to avoid mixing availability with raw latency.
+// 📖 Returns Infinity when no measurable pings exist — this sorts "unknown" models to the bottom.
 // 📖 The rounding to integer avoids displaying fractional milliseconds in the TUI.
 //
 // 📖 Example:
-//   pings = [{ms: 200, code: '200'}, {ms: 0, code: '429'}, {ms: 400, code: '200'}]
-//   → getAvg returns 300 (only the two 200s count: (200+400)/2)
+//   pings = [{ms: 200, code: '200'}, {ms: 320, code: '401'}, {ms: 999, code: '500'}]
+//   → getAvg returns 260 (only the measurable pings count: (200+320)/2)
 export const getAvg = (r) => {
-  const successfulPings = (r.pings || []).filter(p => p.code === '200')
-  if (successfulPings.length === 0) return Infinity
-  return Math.round(successfulPings.reduce((a, b) => a + b.ms, 0) / successfulPings.length)
+  const measurablePings = (r.pings || []).filter(p => measurablePingCodes.has(p.code))
+  if (measurablePings.length === 0) return Infinity
+  return Math.round(measurablePings.reduce((a, b) => a + b.ms, 0) / measurablePings.length)
 }
 
 // 📖 getVerdict: Determine a human-readable health verdict for a model.
@@ -120,16 +125,16 @@ export const getVerdict = (r) => {
   if (avg === Infinity) return 'Pending'
 
   // 📖 Stability-aware verdict: penalize models with good avg but terrible tail latency
-  const successfulPings = (r.pings || []).filter(p => p.code === '200')
+  const measurablePings = (r.pings || []).filter(p => measurablePingCodes.has(p.code))
   const p95 = getP95(r)
 
   if (avg < 400) {
     // 📖 Only flag as "Spiky" when we have enough data (≥3 pings) to judge stability
-    if (successfulPings.length >= 3 && p95 > 3000) return 'Spiky'
+    if (measurablePings.length >= 3 && p95 > 3000) return 'Spiky'
     return 'Perfect'
   }
   if (avg < 1000) {
-    if (successfulPings.length >= 3 && p95 > 5000) return 'Spiky'
+    if (measurablePings.length >= 3 && p95 > 5000) return 'Spiky'
     return 'Normal'
   }
   if (avg < 3000) return 'Slow'
@@ -148,30 +153,30 @@ export const getUptime = (r) => {
   return Math.round((successful / r.pings.length) * 100)
 }
 
-// 📖 getP95: Calculate the 95th percentile latency from successful pings (HTTP 200).
+// 📖 getP95: Calculate the 95th percentile latency from measurable pings (HTTP 200/401).
 // 📖 The p95 answers: "95% of requests are faster than this value."
 // 📖 A low p95 means consistently fast responses — a high p95 signals tail-latency spikes.
-// 📖 Returns Infinity when no successful pings exist.
+// 📖 Returns Infinity when no measurable pings exist.
 //
 // 📖 Algorithm: sort latencies ascending, pick the value at ceil(N * 0.95) - 1.
 // 📖 Example: [100, 200, 300, 400, 5000] → p95 index = ceil(5 * 0.95) - 1 = 4 → 5000ms
 export const getP95 = (r) => {
-  const successfulPings = (r.pings || []).filter(p => p.code === '200')
-  if (successfulPings.length === 0) return Infinity
-  const sorted = successfulPings.map(p => p.ms).sort((a, b) => a - b)
+  const measurablePings = (r.pings || []).filter(p => measurablePingCodes.has(p.code))
+  if (measurablePings.length === 0) return Infinity
+  const sorted = measurablePings.map(p => p.ms).sort((a, b) => a - b)
   const idx = Math.ceil(sorted.length * 0.95) - 1
   return sorted[Math.max(0, idx)]
 }
 
-// 📖 getJitter: Calculate latency standard deviation (σ) from successful pings.
+// 📖 getJitter: Calculate latency standard deviation (σ) from measurable pings.
 // 📖 Low jitter = predictable response times. High jitter = erratic, spiky latency.
-// 📖 Returns 0 when fewer than 2 successful pings (can't compute variance from 1 point).
+// 📖 Returns 0 when fewer than 2 measurable pings (can't compute variance from 1 point).
 // 📖 Uses population σ (divides by N, not N-1) since we have ALL the data, not a sample.
 export const getJitter = (r) => {
-  const successfulPings = (r.pings || []).filter(p => p.code === '200')
-  if (successfulPings.length < 2) return 0
-  const mean = successfulPings.reduce((a, b) => a + b.ms, 0) / successfulPings.length
-  const variance = successfulPings.reduce((sum, p) => sum + (p.ms - mean) ** 2, 0) / successfulPings.length
+  const measurablePings = (r.pings || []).filter(p => measurablePingCodes.has(p.code))
+  if (measurablePings.length < 2) return 0
+  const mean = measurablePings.reduce((a, b) => a + b.ms, 0) / measurablePings.length
+  const variance = measurablePings.reduce((sum, p) => sum + (p.ms - mean) ** 2, 0) / measurablePings.length
   return Math.round(Math.sqrt(variance))
 }
 
@@ -190,14 +195,14 @@ export const getJitter = (r) => {
 //   Model B: avg 400ms, p95 650ms (boringly consistent) → score ~85
 //   In real usage, Model B FEELS faster because it doesn't randomly stall.
 export const getStabilityScore = (r) => {
-  const successfulPings = (r.pings || []).filter(p => p.code === '200')
-  if (successfulPings.length === 0) return -1
+  const measurablePings = (r.pings || []).filter(p => measurablePingCodes.has(p.code))
+  if (measurablePings.length === 0) return -1
 
   const p95 = getP95(r)
   const jitter = getJitter(r)
   const uptime = getUptime(r)
-  const spikeCount = successfulPings.filter(p => p.ms > 3000).length
-  const spikeRate = spikeCount / successfulPings.length
+  const spikeCount = measurablePings.filter(p => p.ms > 3000).length
+  const spikeRate = spikeCount / measurablePings.length
 
   // 📖 Normalize each component to 0–100 (higher = better)
   const p95Score = Math.max(0, Math.min(100, 100 * (1 - p95 / 5000)))