feat: add OnBinary and OnWriteParsed events to Terminal public API

Expose OnBinary (forwarded from CoreService) and OnWriteParsed (fires
after each Write/WriteString call) on the Terminal type, matching the
upstream CoreTerminal public API.

Fixes #36

Co-authored-by: Ona <no-reply@ona.com>

Author: ona-automations

terminal.go

@@ -48,6 +48,7 @@ type Terminal struct {
 	OnResizeEmitter                  EventEmitter[BufferResizeEvent]
 	OnScrollEmitter                  EventEmitter[int]
 	OnRenderEmitter                  EventEmitter[RowRange]
+	OnWriteParsedEmitter             EventEmitter[struct{}]
 	OnRequestColorSchemeQueryEmitter        EventEmitter[struct{}]
 	OnRequestWindowsOptionsReportEmitter    EventEmitter[WindowsOptionsReportType]
 }
@@ -105,12 +106,14 @@ func New(opts ...Option) *Terminal {
 // Write writes data to the terminal, implementing io.Writer.
 func (t *Terminal) Write(p []byte) (n int, err error) {
 	t.inputHandler.Parse(p)
+	t.OnWriteParsedEmitter.Fire(struct{}{})
 	return len(p), nil
 }
 
 // WriteString writes a string to the terminal.
 func (t *Terminal) WriteString(s string) {
 	t.inputHandler.ParseString(s)
+	t.OnWriteParsedEmitter.Fire(struct{}{})
 }
 
 // Resize changes the terminal dimensions.
@@ -213,6 +216,17 @@ func (t *Terminal) OnData(fn func(string)) Disposable {
 	return t.coreService.OnDataEmitter.Event(fn)
 }
 
+// OnBinary subscribes to binary data events from the terminal.
+func (t *Terminal) OnBinary(fn func(string)) Disposable {
+	return t.coreService.OnBinaryEmitter.Event(func(data string) { fn(data) })
+}
+
+// OnWriteParsed subscribes to write-parsed events.
+// Fires after each Write/WriteString call completes parsing.
+func (t *Terminal) OnWriteParsed(fn func()) Disposable {
+	return t.OnWriteParsedEmitter.Event(func(struct{}) { fn() })
+}
+
 // OnBell registers a callback for bell events.
 func (t *Terminal) OnBell(fn func()) Disposable {
 	return t.OnBellEmitter.Event(func(struct{}) { fn() })
@@ -412,6 +426,7 @@ func (t *Terminal) Dispose() {
 	t.OnResizeEmitter.Dispose()
 	t.OnScrollEmitter.Dispose()
 	t.OnRenderEmitter.Dispose()
+	t.OnWriteParsedEmitter.Dispose()
 	t.OnRequestColorSchemeQueryEmitter.Dispose()
 	t.OnRequestWindowsOptionsReportEmitter.Dispose()
 }

terminal_test.go

@@ -1262,5 +1262,87 @@ func TestTerminalOnRequestColorSchemeQueryDispose(t *testing.T) {
 	}
 }
 
+func TestTerminalOnBinary(t *testing.T) {
+	t.Parallel()
+	term := newTestTerminal(80, 24)
+	var got []string
+	term.OnBinary(func(data string) { got = append(got, data) })
+
+	// Trigger a binary event via the core service (the plumbing path).
+	term.coreService.TriggerBinaryEvent("\x1b[2J")
+
+	if len(got) != 1 {
+		t.Fatalf("expected 1 OnBinary event, got %d", len(got))
+	}
+	if got[0] != "\x1b[2J" {
+		t.Errorf("OnBinary data = %q, want %q", got[0], "\x1b[2J")
+	}
+}
+
+func TestTerminalOnBinaryDispose(t *testing.T) {
+	t.Parallel()
+	term := newTestTerminal(80, 24)
+	count := 0
+	d := term.OnBinary(func(string) { count++ })
+
+	term.coreService.TriggerBinaryEvent("data1")
+	if count != 1 {
+		t.Fatalf("expected 1 fire before dispose, got %d", count)
+	}
+
+	d.Dispose()
+	term.coreService.TriggerBinaryEvent("data2")
+	if count != 1 {
+		t.Errorf("OnBinary fired after Dispose: count = %d, want 1", count)
+	}
+}
+
+func TestTerminalOnWriteParsed(t *testing.T) {
+	t.Parallel()
+	term := newTestTerminal(80, 24)
+	count := 0
+	term.OnWriteParsed(func() { count++ })
+
+	term.WriteString("hello")
+	if count != 1 {
+		t.Fatalf("expected 1 OnWriteParsed after WriteString, got %d", count)
+	}
+
+	term.Write([]byte("world"))
+	if count != 2 {
+		t.Fatalf("expected 2 OnWriteParsed after Write, got %d", count)
+	}
+}
+
+func TestTerminalOnWriteParsedDispose(t *testing.T) {
+	t.Parallel()
+	term := newTestTerminal(80, 24)
+	count := 0
+	d := term.OnWriteParsed(func() { count++ })
+
+	term.WriteString("hello")
+	if count != 1 {
+		t.Fatalf("expected 1 fire before dispose, got %d", count)
+	}
+
+	d.Dispose()
+	term.WriteString("world")
+	if count != 1 {
+		t.Errorf("OnWriteParsed fired after Dispose: count = %d, want 1", count)
+	}
+}
 
+func TestTerminalOnWriteParsedMultipleWrites(t *testing.T) {
+	t.Parallel()
+	term := newTestTerminal(80, 24)
+	count := 0
+	term.OnWriteParsed(func() { count++ })
 
+	// Each write should fire exactly once.
+	for i := range 5 {
+		term.WriteString(fmt.Sprintf("line %d\r\n", i))
+	}
+	if count != 5 {
+		t.Errorf("expected 5 OnWriteParsed fires, got %d", count)
+	}
+}