@ymys4ever/opencode-throughput-v2 4.0.0 → 4.0.2

package/src/format/entry.ts

@@ -1,39 +0,0 @@
-import type { LogEntry } from "../types.js"
-
-/** Format a millisecond duration; null (no sample) renders as "N/A". */
-export function formatMs(ms: number | null): string {
-  if (ms == null) return "N/A"
-  if (ms >= 60000) return (ms / 60000).toFixed(1) + "m"
-  if (ms >= 1000) return (ms / 1000).toFixed(1) + "s"
-  return ms.toFixed(0) + "ms"
-}
-
-/** Shared implementation for compact number rendering (k/M suffixes). */
-export function formatTokenCount(n: number): string {
-  if (n >= 1e6) return (n / 1e6).toFixed(2) + "M"
-  if (n >= 1e3) return (n / 1e3).toFixed(1) + "k"
-  return n.toFixed(n >= 100 ? 0 : 1)
-}
-
-/** Format a numeric metric; null (no sample) renders as "N/A". */
-export function formatNum(n: number | null): string {
-  if (n == null) return "N/A"
-  return formatTokenCount(n)
-}
-
-/** Single project-wide truncation: overlong strings become (max - 1) chars + "…". */
-export function truncate(s: string, max: number): string {
-  return s.length > max ? s.slice(0, max - 1) + "…" : s
-}
-
-/** Toast line: model | TTFT | tok/s | latency | ↑in ↓out. */
-export function buildLogMsg(entry: LogEntry): string {
-  const parts = [
-    truncate(entry.modelID, 28),
-    formatMs(entry.ttft_ms) + " TTFT",
-    formatNum(entry.tps) + " tok/s",
-    formatMs(entry.latency_ms),
-    "\u2191" + formatNum(entry.inputTokens) + " \u2193" + formatNum(entry.outputTokens),
-  ]
-  return parts.join(" | ")
-}

package/src/format/perf.ts

@@ -1,14 +0,0 @@
-import type { LogEntry } from "../types.js"
-import { formatMs, formatNum } from "./entry.js"
-
-/** Markdown perf-file line (frozen format; trailing newline included). */
-export function formatPerfLine(entry: LogEntry): string {
-  const finishSuffix = entry.finish && entry.finish !== "stop" ? " | " + entry.finish : ""
-  return (
-    `${entry.ts} | ${entry.modelID} | TTFT ${formatMs(entry.ttft_ms)}` +
-    ` | TPS ${formatNum(entry.tps)} tok/s | Latency ${formatMs(entry.latency_ms)}` +
-    ` | \u2191${formatNum(entry.inputTokens)} \u2193${formatNum(entry.outputTokens)}` +
-    ` \u2193r${formatNum(entry.reasoningTokens)} | Cost $${entry.cost.toFixed(4)}` +
-    `${finishSuffix}\n`
-  )
-}

package/src/index.ts

@@ -1,19 +0,0 @@
-import { aggregateAt } from "./core/stats.js"
-import type { LogEntry, ModelStats } from "./types.js"
-
-export { createThroughputPlugin, ThroughputPlugin } from "./plugins/throughput.js"
-export { default } from "./plugins/throughput.js"
-export type { ThroughputPluginOptions } from "./plugins/throughput.js"
-export { createLogStore } from "./io/log-store.js"
-export type { LogStore } from "./io/log-store.js"
-
-/**
- * Deprecated facade over aggregateAt — the public API is frozen, semantics
- * unchanged. The library's single default-clock point lives here on purpose:
- * index.ts is outside the src/core purity guard (test/guard.test.ts).
- */
-export function aggregate(entries: readonly LogEntry[]): Map<string, ModelStats> {
-  return aggregateAt(entries, Date.now())
-}
-
-export type { LogEntry, ModelStats }

package/src/io/log-store.ts

@@ -1,55 +0,0 @@
-import type { LogEntry } from "../types.js"
-import { decodeLogContent, encodeLogEntry } from "../core/log-codec.js"
-import fs from "fs"
-import os from "os"
-import path from "path"
-
-export interface LogStore {
-  /**
-   * Fault-tolerant append: dir creation memoized; sync appendFileSync; IO
-   * errors go to onError (default console.warn), never thrown.
-   */
-  append(entry: LogEntry): void
-  /**
-   * ENOENT -> empty; decode-tolerant (skips corrupt lines, counts them);
-   * other IO errors (e.g. EACCES) are thrown to caller.
-   */
-  read(): { entries: LogEntry[]; skipped: number }
-}
-
-export function createLogStore(opts?: {
-  file?: string
-  onError?: (e: unknown) => void
-}): LogStore {
-  const file = opts?.file ?? path.join(os.homedir(), ".opencode", "throughput.jsonl")
-  const onError = opts?.onError ?? ((e: unknown) => console.warn(e))
-
-  // Memoized on success only: a failed mkdir retries on the next append.
-  let dirReady = false
-  const ensureDir = (): void => {
-    if (dirReady) return
-    fs.mkdirSync(path.dirname(file), { recursive: true })
-    dirReady = true
-  }
-
-  return {
-    append(entry) {
-      try {
-        ensureDir()
-        fs.appendFileSync(file, encodeLogEntry(entry), "utf-8")
-      } catch (e) {
-        onError(e)
-      }
-    },
-    read() {
-      let content: string
-      try {
-        content = fs.readFileSync(file, "utf-8")
-      } catch (e) {
-        if ((e as NodeJS.ErrnoException).code === "ENOENT") return { entries: [], skipped: 0 }
-        throw e
-      }
-      return decodeLogContent(content)
-    },
-  }
-}

package/src/io/perf-file.ts

@@ -1,30 +0,0 @@
-import type { LogEntry } from "../types.js"
-import { formatPerfLine } from "../format/perf.js"
-import fs from "fs"
-import path from "path"
-
-/**
- * Appends formatPerfLine(entry) to <directory>/.opencode/throughput.md.
- * Fully fault-tolerant: any IO error is reported to onError (default: silent)
- * and never thrown. Dir creation is memoized on success.
- */
-export function createPerfFileWriter(
-  directory: string,
-  onError?: (e: unknown) => void
-): (entry: LogEntry) => void {
-  const file = path.join(directory, ".opencode", "throughput.md")
-  const handleError = onError ?? (() => {})
-
-  let dirReady = false
-  return (entry: LogEntry) => {
-    try {
-      if (!dirReady) {
-        fs.mkdirSync(path.dirname(file), { recursive: true })
-        dirReady = true
-      }
-      fs.appendFileSync(file, formatPerfLine(entry), "utf-8")
-    } catch (e) {
-      handleError(e)
-    }
-  }
-}

package/src/plugins/throughput.ts

@@ -1,124 +0,0 @@
-import { Plugin } from "@opencode/plugin"
-import type { LogEntry } from "../types.js"
-import { StepTracker } from "../core/step-tracker.js"
-import { createPipeline, makeSafeOnError } from "../runtime/pipeline.js"
-import { makeOwns } from "../core/ownership.js"
-import { createLogStore, type LogStore } from "../io/log-store.js"
-import { createPerfFileWriter } from "../io/perf-file.js"
-import { executeBenchmark } from "../benchmark.js"
-
-export type ThroughputPluginOptions = {
-  /** Injected persistence; defaults to the global ~/.opencode/throughput.jsonl store. */
-  logStore?: LogStore
-  /** Diagnostics sink for per-event failures (default: console.error). Never kills the subscription. */
-  onError?: (e: unknown) => void
-  /** Clock injection for tests. */
-  now?: () => number
-  /** Grace window for late terminal events after session.idle before an entry is recorded as finish:"aborted" (default 5000). */
-  abortTtlMs?: number
-  /** Fallback eviction window for active steps that receive neither a terminal event nor session.idle, in ms (default 600000 = 10 min; 0 or negative disables). */
-  activeTtlMs?: number
-}
-
-export function createThroughputPlugin(options: ThroughputPluginOptions = {}) {
-  return Plugin.define({
-    id: "opencode-throughput",
-    async setup(ctx) {
-      const onError = options.onError ?? ((e: unknown) => console.error(e))
-      const tracker = new StepTracker({ activeTtlMs: options.activeTtlMs })
-      const logStore = options.logStore ?? createLogStore({ onError })
-      const writePerf = createPerfFileWriter(ctx.location.directory, onError)
-      const owns = makeOwns(ctx.location.directory)
-      const now = options.now ?? Date.now
-      const abortTtlMs = options.abortTtlMs ?? 5000
-
-      await ctx.tool.transform((editor) => {
-        editor.add({
-          name: "benchmark",
-          description:
-            "Query model performance benchmarks including latency, throughput (TTFT, TPS), token usage, and cost. Shows stats aggregated by model.",
-          input: {
-            type: "object",
-            properties: {
-              model: {
-                type: "string",
-                description:
-                  "Filter by model name (partial match, e.g. 'claude' or 'gpt'). Omit for all models.",
-              },
-              last: {
-                type: "integer",
-                minimum: 1,
-                description: "Only show the last N entries (default: show all)",
-              },
-            },
-            additionalProperties: false,
-          },
-          async execute(args) {
-            return await executeBenchmark(args, { logStore })
-          },
-        })
-      })
-
-      const controller = new AbortController()
-
-      // Per-sink isolation: each sink gets its own boundary, so a failing
-      // append never skips the perf file (and vice versa). Default sinks
-      // never throw; injected sinks may.
-      function record(entry: LogEntry) {
-        try {
-          logStore.append(entry)
-        } catch (e) {
-          onError(e)
-        }
-        try {
-          writePerf(entry)
-        } catch (e) {
-          onError(e)
-        }
-      }
-
-      const pipeline = createPipeline({
-        tracker,
-        owns,
-        now,
-        abortTtlMs,
-        onEntry: record,
-        onError,
-        timers: {
-          set: (cb, ms) => setTimeout(cb, ms),
-          clear: (h) => clearTimeout(h as Parameters<typeof clearTimeout>[0]),
-        },
-      })
-
-      const task = (async () => {
-        // dispatch() is designed never to throw (it owns the per-event error
-        // boundary); task.catch below remains the last resort if the
-        // subscription itself dies.
-        for await (const ev of ctx.event.subscribe({ signal: controller.signal })) {
-          pipeline.dispatch(ev)
-        }
-      })()
-      // Last resort if the subscription itself dies (e.g. the host adapter
-      // fails to encode an event before it reaches the plugin). Report with
-      // plugin identity, keep the original as `cause`, and stay fail-stop:
-      // no resubscribe. A throwing onError here is swallowed by safeOnError.
-      const reportSubscriptionDeath = makeSafeOnError(onError)
-      task.catch((e: unknown) => {
-        reportSubscriptionDeath(
-          new Error(`throughput: event subscription died: ${e instanceof Error ? e.message : String(e)}`, {
-            cause: e,
-          })
-        )
-      })
-
-      return () => {
-        pipeline.dispose()
-        controller.abort()
-      }
-    },
-  })
-}
-
-/** Back-compat default instance (path & exports unchanged). */
-export const ThroughputPlugin = createThroughputPlugin()
-export default ThroughputPlugin

package/src/runtime/pipeline.ts

@@ -1,163 +0,0 @@
-import type { StepTracker } from "../core/step-tracker.js"
-import { buildAbortedEntry } from "../core/step-tracker.js"
-import { normalizeEvent, applyThroughputEvent } from "../core/events.js"
-import type { LocationLike } from "../core/ownership.js"
-import type { LogEntry } from "../types.js"
-
-/**
- * Timer port: a minimal injectable subset of the host timer API. Wrapping
- * calls (arrow functions at the assembly layer) avoids `this`-binding issues
- * with bare host references.
- */
-export type TimerPort = {
-  set: (cb: () => void, ms: number) => unknown
-  clear: (handle: unknown) => void
-}
-
-export type PipelineDeps = {
-  tracker: StepTracker
-  owns: (ev: LocationLike) => boolean
-  now: () => number
-  abortTtlMs: number
-  onEntry: (entry: LogEntry) => void
-  onError: (e: unknown) => void
-  timers?: TimerPort
-}
-
-/**
- * Wrap a user-supplied onError so a reporter that throws itself never
- * escapes the pipeline. The failure is reported via console.error; if
- * console.error itself throws, that propagates unchecked by design.
- * (Stage labels — owns/handler/drain/timer — live in code comments only;
- * the public onError signature stays single-arg.)
- *
- * Internal export: shared with the assembly layers (e.g. the server's
- * subscription-death reporter); not part of the public index.ts surface.
- */
-export function makeSafeOnError(onError: (e: unknown) => void): (e: unknown) => void {
-  return (e) => {
-    try {
-      onError(e)
-    } catch (reporterError) {
-      console.error(reporterError)
-    }
-  }
-}
-
-/**
- * Shared engine for both entrypoints: event normalization + application,
- * opportunistic expiry drain, and single-timer deadline management.
- *
- * Semantics (phase-3 rulings):
- * - Non-owned events return immediately: no drain, no re-arm (server rule).
- * - Owned events always drain + re-arm in a finally — including unknown
- *   event types (previous switch fall-through) and after handler failures.
- * - `recordedAt = now()` is taken only for known events, right before apply.
- * - The flush callback re-arms in a finally, so a drain failure never
- *   breaks the deadline chain.
- * - After dispose(), dispatch is a no-op and the armed timer is cleared.
- *
- * Internal module: not part of the public index.ts surface (tests may deep
- * path import).
- */
-export function createPipeline(deps: PipelineDeps): {
-  dispatch(raw: unknown): void
-  dispose(): void
-} {
-  const timers: TimerPort =
-    deps.timers ?? {
-      set: (cb, ms) => setTimeout(cb, ms),
-      clear: (h) => clearTimeout(h as Parameters<typeof clearTimeout>[0]),
-    }
-  const safeOnError = makeSafeOnError(deps.onError)
-  const { tracker, now, abortTtlMs, onEntry } = deps
-
-  let flushTimer: unknown = null
-  let disposed = false
-
-  function drainExpired(): void {
-    for (const { assistantMessageID, state } of tracker.collectExpired(now())) {
-      try {
-        // Per-record boundary: one failing record never drops the remaining expired entries.
-        onEntry(buildAbortedEntry(state, assistantMessageID, now()))
-      } catch (e) {
-        // drain stage
-        safeOnError(e)
-      }
-    }
-  }
-
-  // One timer targeting the earliest parked deadline; only its callback clears the handle.
-  function rearm(): void {
-    if (flushTimer != null) timers.clear(flushTimer)
-    flushTimer = null
-    if (disposed) return
-    const next = tracker.nextDeadline()
-    if (next == null) return
-    flushTimer = timers.set(() => {
-      flushTimer = null
-      if (disposed) return
-      try {
-        // timer stage; drainExpired is per-record guarded — this outer try
-        // only catches unexpected collectExpired/nextDeadline failures.
-        drainExpired()
-      } catch (e) {
-        safeOnError(e)
-      } finally {
-        rearm()
-      }
-    }, Math.max(0, next - now()))
-  }
-
-  function dispatch(raw: unknown): void {
-    if (disposed) return // post-dispose dispatch is a no-op
-
-    // owns stage: reading ev.location may throw; current semantics = report
-    // and skip this turn entirely (no drain).
-    let owned: boolean
-    try {
-      owned = deps.owns(raw as LocationLike)
-    } catch (e) {
-      safeOnError(e)
-      return
-    }
-    if (!owned) return // not owned: no drain, no re-arm
-
-    const n = normalizeEvent(raw)
-    if (!n.ok && n.reason === "malformed") {
-      // Reserved channel, currently unreachable: normalizeEvent never
-      // returns "malformed". Wired conservatively: report and skip the turn.
-      safeOnError(new Error("throughput: malformed event rejected"))
-      return
-    }
-
-    try {
-      if (n.ok) {
-        // handler stage: recordedAt is taken only for known events, just
-        // before apply (unknown events never read the clock here).
-        const recordedAt = now()
-        const entry = applyThroughputEvent(tracker, n.event, { recordedAt, abortTtlMs })
-        if (entry) onEntry(entry)
-      }
-    } catch (e) {
-      // handler stage (payload property access or the entry sink)
-      safeOnError(e)
-    } finally {
-      // Owned events always drain + re-arm — unknown types included, and
-      // even when the handler above failed.
-      drainExpired()
-      rearm()
-    }
-  }
-
-  function dispose(): void {
-    if (disposed) return
-    disposed = true
-    if (flushTimer != null) {
-      timers.clear(flushTimer)
-      flushTimer = null
-    }
-  }
-
-  return { dispatch, dispose }
-}

package/src/tui/controller.ts

@@ -1,191 +0,0 @@
-// No solid-js here: under host worker conditions it may resolve to the SSR
-// build or a different instance than the renderer's; reactivity flows through the host store.
-import type { LogEntry } from "../types.js"
-import { StepTracker } from "../core/step-tracker.js"
-import { SUBSCRIBED_EVENT_TYPES } from "../core/events.js"
-import { createPipeline } from "../runtime/pipeline.js"
-import { makeOwns } from "../core/ownership.js"
-import { aggregateAt } from "../core/stats.js"
-import { buildLogMsg } from "../format/entry.js"
-import { buildDisplayIds, type StatsRow } from "../ui/sidebar.js"
-
-export type ThroughputTuiOptions = {
-  /** Diagnostics sink for per-event failures (default: console.error). Never kills a subscription. */
-  onError?: (e: unknown) => void
-  /** Clock injection for tests. */
-  now?: () => number
-  /** Grace window for late terminal events after session.idle before an entry is recorded as finish:"aborted" (default 5000). */
-  abortTtlMs?: number
-  /** Fallback eviction window for active steps that receive neither a terminal event nor session.idle, in ms (default 600000 = 10 min; 0 or negative disables). */
-  activeTtlMs?: number
-}
-
-/** Structural subset of the real TUI plugin context (kept local for testability). */
-export type TuiContext = {
-  location?: { directory?: string }
-  data: { on: (type: string, handler: (ev: any) => void) => () => void }
-  ui: {
-    toast: {
-      show: (toast: { title: string; message: string; variant: string; duration: number }) => void
-    }
-  }
-  /** Host render hook; keeps the sidebar live regardless of the plugin-side solid build. */
-  renderer?: { requestRender: () => void }
-  /** Host live store — the only reactive channel reaching the JSX runtime; optional so tests inject a plain fallback. */
-  storage?: {
-    memory: <Value extends object>(
-      key: string,
-      options: { readonly initial: Value }
-    ) => readonly [Value, (mutation: (draft: Value) => void) => void]
-  }
-}
-
-// StatsRow now lives with the sidebar layout code (ui/sidebar.ts); re-exported
-// here so the controller's public type surface is unchanged for consumers.
-export type { StatsRow } from "../ui/sidebar.js"
-
-/** Recent entries shown in the sidebar; keeps the widget small. */
-const MAX_RECENT = 10
-/** Per-model history cap feeding aggregate(); bounds memory on long sessions. */
-const BUFFER_CAP = 200
-
-/** Sidebar state published to the host store. */
-export type ThroughputLiveState = {
-  open: boolean
-  recent: LogEntry[]
-  rows: StatsRow[]
-}
-
-/**
- * Testable core of the TUI entry: owns the same event wiring as the server
- * plugin but publishes sidebar state through the host's live store.
- */
-export function createThroughputController(
-  context: TuiContext,
-  options: ThroughputTuiOptions = {}
-): {
-  recent: () => LogEntry[]
-  statsRows: () => StatsRow[]
-  open: () => boolean
-  toggleOpen: () => void
-  unsubscribe: () => void
-} {
-  const onError = options.onError ?? ((e: unknown) => console.error(e))
-  const now = options.now ?? Date.now
-  const abortTtlMs = options.abortTtlMs ?? 5000
-
-  const tracker = new StepTracker({ activeTtlMs: options.activeTtlMs })
-  // Sidebar-only history: the TUI renders per-model aggregates from this
-  // in-memory buffer; persistent logging is the server plugin's job.
-  const buffers = new Map<string, LogEntry[]>()
-  const owns = makeOwns(context.location?.directory)
-
-  // Live state via the host store (reactive in the renderer's world) with a
-  // plain-object fallback for hostless environments (tests).
-  const initial: ThroughputLiveState = { open: true, recent: [], rows: [] }
-  let fallback: ThroughputLiveState = { ...initial }
-  const store = context.storage?.memory("opencode-throughput:tui", { initial })
-  // Hot-reload reset (PR-B): unconditional construction-time reset. The
-  // closure buffers are per-instance and start empty, and the store is only
-  // an in-process channel between this controller and the renderer —
-  // cross-generation persistence (any shape) would render as ghost rows
-  // that collapse on the first record. Construction happens exactly once
-  // per generation, so resetting here is strictly correct; a throwing store
-  // mutation is reported, never fatal.
-  if (store) {
-    try {
-      store[1]((draft) => {
-        draft.open = true
-        draft.recent = []
-        draft.rows = []
-      })
-    } catch (e) {
-      onError(e)
-    }
-  }
-  const read = (): ThroughputLiveState => (store ? store[0] : fallback)
-  const mutate = (fn: (draft: ThroughputLiveState) => void): void => {
-    if (store) store[1](fn)
-    else fn(fallback)
-    context.renderer?.requestRender()
-  }
-
-  // Stats are recomputed eagerly on every record(); every recompute returns
-  // brand-new row/stats objects so identity-based consumers always see
-  // fresh rows.
-  function recomputeRows(): StatsRow[] {
-    const modelIDs = new Set<string>()
-    for (const entries of buffers.values()) modelIDs.add(entries[entries.length - 1].modelID)
-    // Display IDs are stable across recomputes: first-seen keeps the 3-char form (see buildDisplayIds).
-    const displayIds = buildDisplayIds([...modelIDs])
-    const rows: StatsRow[] = []
-    for (const [modelKey, entries] of buffers) {
-      const stats = aggregateAt(entries, now()).get(modelKey)
-      if (!stats) continue
-      // modelID taken from the model's most recent entry (structured, not
-      // split from the aggregate key).
-      const modelID = entries[entries.length - 1].modelID
-      rows.push({ stats, modelID, displayID: displayIds.get(modelID)! })
-    }
-    return rows
-  }
-
-  function showToast(entry: LogEntry) {
-    context.ui.toast.show({
-      title: "Throughput",
-      message: buildLogMsg(entry),
-      // "aborted" is a normal lifecycle outcome, not a failure; every other non-stop finish warns.
-      variant: entry.finish === "stop" || entry.finish === "aborted" ? "info" : "warning",
-      duration: 4000,
-    })
-  }
-
-  function record(entry: LogEntry) {
-    const buffer = buffers.get(entry.model) ?? []
-    buffer.push(entry)
-    if (buffer.length > BUFFER_CAP) buffer.splice(0, buffer.length - BUFFER_CAP)
-    buffers.set(entry.model, buffer)
-    const rows = recomputeRows()
-    mutate((draft) => {
-      const next = [...draft.recent, entry]
-      draft.recent = next.length > MAX_RECENT ? next.slice(-MAX_RECENT) : next
-      draft.rows = rows
-    })
-    showToast(entry)
-  }
-
-  // Shared engine: owns routing, event application, expiry drain and the
-  // single flush timer (see runtime/pipeline.ts).
-  const pipeline = createPipeline({
-    tracker,
-    owns,
-    now,
-    abortTtlMs,
-    onEntry: record,
-    onError,
-    timers: {
-      set: (cb, ms) => setTimeout(cb, ms),
-      clear: (h) => clearTimeout(h as Parameters<typeof clearTimeout>[0]),
-    },
-  })
-
-  // Single subscription handler for all monitored event types (the type
-  // routing itself lives in core/events.ts). `ev: any` is the one allowed
-  // controlled cast at the host boundary.
-  const onSessionEvent = (ev: any) => pipeline.dispatch(ev)
-
-  const stops = SUBSCRIBED_EVENT_TYPES.map((t) => context.data.on(t, onSessionEvent))
-
-  function unsubscribe() {
-    pipeline.dispose()
-    for (const off of stops) off()
-  }
-
-  return {
-    recent: () => read().recent,
-    statsRows: () => read().rows,
-    open: () => read().open,
-    toggleOpen: () => mutate((draft) => { draft.open = !draft.open }),
-    unsubscribe,
-  }
-}

package/src/tui.tsx

@@ -1,36 +0,0 @@
-import { Plugin } from "@opencode/plugin/tui"
-import {
-  createThroughputController,
-  type TuiContext,
-  type ThroughputTuiOptions,
-} from "./tui/controller.js"
-import { ThroughputWidget, type ThemeTokens } from "./ui/throughput-widget.js"
-
-export function createThroughputTuiPlugin(options: ThroughputTuiOptions = {}) {
-  return Plugin.define({
-    id: "opencode-throughput",
-    setup(context) {
-      // Structural bridge to keep the controller testable without host SDK types.
-      const controller = createThroughputController(context as TuiContext, options)
-      const stopSlot = context.ui.slot({
-        append: "sidebar.content",
-        render: () =>
-          ThroughputWidget({
-            theme: context.theme as ThemeTokens,
-            recent: controller.recent,
-            stats: controller.statsRows,
-            open: controller.open,
-            onToggle: controller.toggleOpen,
-          }),
-      })
-      return () => {
-        stopSlot()
-        controller.unsubscribe()
-      }
-    },
-  })
-}
-
-/** Back-compat default instance (path & exports unchanged). */
-export const ThroughputTuiPlugin = createThroughputTuiPlugin()
-export default ThroughputTuiPlugin