invert dependency: internal no longer imports internal/tui

Introduce internal/runtime as a neutral contract package that both the
core engine (internal) and the TUI layer (internal/tui) depend on.

- internal/runtime: defines TraceStarter, StreamSource, EventSink,
  LiveTrieSource, SnapshotSource, ProbeManager, RuntimePublisher,
  RuntimeState, TraceRuntimeBindings, and all context key/helper
  functions (RuntimeBindingsFromContext, RuntimePublisherFromContext,
  ContextWithRuntimeBindings, ContextWithTraceFilters,
  TraceFiltersFromContext). These were previously defined in
  internal/tui, forcing the core package to import the TUI layer.

- internal/streamrow: add RingBuffer (moved from internal/tui/eventstream)
  so the core tracing engine can use the ring buffer without importing
  the TUI layer.

- internal/tui/eventstream/ringbuffer.go: change to a thin re-export of
  streamrow.RingBuffer via a type alias, preserving the existing API for
  all callers within the TUI layer.

- internal/tui/tui.go: replace locally-defined interface declarations
  (TraceStarter, SnapshotSource, ProbeManager, RuntimePublisher,
  RuntimeState, TraceRuntimeBindings) with type aliases from
  internal/runtime. Delegate all context helper functions to runtime.

- internal/ior.go, internal/ior_bpfsetup.go: remove imports of
  internal/tui and internal/tui/eventstream; use internal/runtime and
  internal/streamrow instead. Add SetTUIRunners injection point so the
  concrete TUI runner functions are wired in by cmd/ior/main.go.

- cmd/ior/main.go: call internal.SetTUIRunners with the concrete TUI
  runner functions before internal.Run, completing the wiring without
  creating a cycle.

- Test files (internal/ior_mode_test.go, internal/bench_pipeline_test.go):
  updated to use runtime.* and streamrow.* types in place of tui.* and
  eventstream.* types.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

1 files changed, 10 insertions, 62 deletions

diff --git a/internal/tui/eventstream/ringbuffer.go b/internal/tui/eventstream/ringbuffer.go
index 87dacae..8644b42 100644
--- a/internal/tui/eventstream/ringbuffer.go
+++ b/internal/tui/eventstream/ringbuffer.go
@@ -1,69 +1,17 @@
 package eventstream
 
-import "sync"
+import "ior/internal/streamrow"
 
-const ringBufferCapacity = 10000
+// RingBuffer is a type alias for streamrow.RingBuffer. The concrete
+// implementation lives in the lower-level streamrow package so the core
+// tracing engine can use it without importing internal/tui/eventstream.
+type RingBuffer = streamrow.RingBuffer
 
-type RingBuffer struct {
-	mu          sync.RWMutex
-	buf         []StreamEvent
-	start       int
-	size        int
-	totalPushed uint64
-}
+// ringBufferCapacity mirrors the capacity constant for use in this package
+// (e.g. stream table rendering).
+const ringBufferCapacity = streamrow.RingBufferCapacity
 
+// NewRingBuffer allocates an empty RingBuffer with the default capacity.
 func NewRingBuffer() *RingBuffer {
-	return &RingBuffer{buf: make([]StreamEvent, ringBufferCapacity)}
-}
-
-func (r *RingBuffer) Push(ev StreamEvent) {
-	r.mu.Lock()
-	defer r.mu.Unlock()
-
-	if r.size < ringBufferCapacity {
-		idx := (r.start + r.size) % ringBufferCapacity
-		r.buf[idx] = ev
-		r.size++
-	} else {
-		r.buf[r.start] = ev
-		r.start = (r.start + 1) % ringBufferCapacity
-	}
-	r.totalPushed++
-}
-
-func (r *RingBuffer) Snapshot() []StreamEvent {
-	r.mu.RLock()
-	defer r.mu.RUnlock()
-
-	if r.size == 0 {
-		return make([]StreamEvent, 0)
-	}
-
-	out := make([]StreamEvent, r.size)
-	for i := 0; i < r.size; i++ {
-		out[i] = r.buf[(r.start+i)%ringBufferCapacity]
-	}
-	return out
-}
-
-func (r *RingBuffer) Len() int {
-	r.mu.RLock()
-	defer r.mu.RUnlock()
-	return r.size
-}
-
-func (r *RingBuffer) TotalPushed() uint64 {
-	r.mu.RLock()
-	defer r.mu.RUnlock()
-	return r.totalPushed
-}
-
-func (r *RingBuffer) Reset() {
-	r.mu.Lock()
-	defer r.mu.Unlock()
-
-	clear(r.buf)
-	r.start = 0
-	r.size = 0
-	r.totalPushed = 0
+	return streamrow.NewRingBuffer()
 }