screen

type AltPainter ¶

type AltPainter struct {
	// contains filtered or unexported fields
}

AltPainter renders the session into the terminal's alternate screen: a fixed-size viewport that it repaints in full each frame with absolute cursor addressing. It is the fallback for emulators where the inline Painter's scroll-region insertion is unsafe (Zellij-class multiplexers), so it cannot lean on the terminal's own scrollback the way Painter does; instead it keeps a bounded transcript of its own and always draws the tail, the newest output with the composer beneath it. Entering and leaving the alternate screen is the term package's job, symmetric with the other terminal modes; this type only draws inside it.

Like Painter it is pure with respect to the terminal (it reads nothing back) and every write is one synchronized frame, so a repaint never tears. Write errors are sticky: after the first failure every later operation is a no-op and Err reports the cause.

func NewAltPainter(w io.Writer, width, height int) *AltPainter

func (p *AltPainter) Close()

func (p *AltPainter) Err() error

func (p *AltPainter) Insert(finalized, frame []string)

func (p *AltPainter) Live() []string

func (p *AltPainter) Paint(frame []string)

func (p *AltPainter) Repaint(frame []string)

func (p *AltPainter) Resize(width, height int)

type Component ¶

type Component interface {
	Render(width int) []string
}

Component is anything that can render itself as lines at a given width. Each returned string is one terminal row, already styled and already wrapped: the painter treats every line as exactly one row and hard-guards overflow by truncation, so a component that wants wrapping does it here.

type Painter ¶

type Painter struct {
	// contains filtered or unexported fields
}

Painter owns the live region: the last few rows of the terminal, repainted in place as the session streams. It tracks only the lines it last painted and the terminal size; it never queries the terminal. The cursor contract is simple and holds across every operation: the cursor rests at column one of the last live row (or at column one of the row where the live region will begin, while the region is empty).

All movement is relative (cursor up and down from that resting row), never absolute. Relative movement stays correct when the terminal scrolls, because the cursor and the live rows scroll together; absolute addressing would not.

Each operation is accumulated into one buffer and flushed as a single write wrapped in synchronized output, so the terminal applies it as one atomic frame. Write errors are sticky: after the first failure every later operation is a no-op and Err reports the cause, so a torn-down terminal does not produce a cascade of secondary failures mid-exit.

func NewPainter(w io.Writer, width, height int) *Painter

func (p *Painter) Close()

func (p *Painter) Err() error

func (p *Painter) Insert(finalized, frame []string)

func (p *Painter) Live() []string

func (p *Painter) Paint(frame []string)

func (p *Painter) Repaint(frame []string)

func (p *Painter) Resize(width, height int)

type Scheduler ¶

type Scheduler struct {
	// contains filtered or unexported fields
}

Scheduler coalesces repaint requests into frames at a bounded rate. Every producer (a streaming token, a spinner tick, a keystroke echo) calls Request whenever anything changes; the scheduler guarantees the paint function runs soon after the first request and then at most once per interval, however many requests arrive in between. Fast streaming therefore costs one repaint per frame, not one per token, and the renderer can never fall behind its input.

Time comes from the injected clock.Timing, never the wall clock, keeping frame pacing on the same deterministic footing as the rest of the runtime: production wires clock.System, tests drive a clock.Manual and observe exact coalescing behavior with no sleeps.

func NewScheduler(timing clock.Timing, interval time.Duration, paint func()) *Scheduler

func (s *Scheduler) Request()

func (s *Scheduler) Stop()

type Surface ¶

type Surface interface {
	// Resize records a new terminal size; the next paint re-renders at it.
	Resize(width, height int)
	// Paint shows frame as the live region, writing only what changed.
	Paint(frame []string)
	// Insert commits finalized above the live region, then shows frame.
	Insert(finalized, frame []string)
	// Repaint redraws frame from scratch, discarding any stale diff base.
	Repaint(frame []string)
	// Close finalizes the session's last frame and releases the surface.
	Close()
	// Err returns the first write error the surface hit, or nil.
	Err() error
}

Surface is the render target the shell drives: it turns frames into terminal writes and owns whatever region of the terminal the session paints. Two implementations back it. Painter renders inline and commits finalized lines to the terminal's own scrollback, so native scrolling, selection, and search keep working on the whole transcript; it is the default and the full-fidelity path. AltPainter renders in the alternate screen for emulators where the inline path's scroll-region insertion is unsafe (Zellij-class multiplexers): it keeps its own bounded scrollback and repaints a full-screen viewport.

Both share the same contract, so the shell drives either without knowing which it holds. Every method is a no-op after the first write error, which Err reports.