@effect-tui/core 0.1.1 → 0.1.4

package/src/layout/linearStack.ts

@@ -1,115 +0,0 @@
-// linearStack.ts — SwiftUI-like linear stacks with flexible children
-
-export type Axis = "horizontal" | "vertical"
-export type Size = { w: number; h: number }
-export type Rect = { x: number; y: number; w: number; h: number }
-export type HAlign = "leading" | "center" | "trailing"
-export type VAlign = "top" | "center" | "bottom"
-
-/** flexBase[i] = null for fixed, or the child's base main-size for flexible. */
-export function measureLinear(
-  axis: Axis,
-  maxW: number,
-  maxH: number,
-  spacing: number,
-  sizes: Size[],
-  flexBase: (number | null)[],
-): Size {
-  const n = sizes.length
-  const gaps = Math.max(0, n - 1) * Math.max(0, spacing)
-
-  let mainSum = 0
-  let crossMax = 0
-  let hasFlex = false
-
-  for (let i = 0; i < n; i++) {
-    const s = sizes[i]
-    if (!s) continue
-    const main = axis === "horizontal" ? s.w : s.h
-    const cross = axis === "horizontal" ? s.h : s.w
-    crossMax = Math.max(crossMax, cross)
-    hasFlex ||= flexBase[i] != null
-    mainSum += flexBase[i] ?? main
-  }
-
-  const maxMain = axis === "horizontal" ? maxW : maxH
-  const totalMain = hasFlex ? maxMain : Math.min(maxMain, mainSum + gaps)
-
-  return axis === "horizontal"
-    ? { w: Math.min(maxW, totalMain), h: Math.min(maxH, crossMax) }
-    : { w: Math.min(maxW, crossMax), h: Math.min(maxH, totalMain) }
-}
-
-export function layoutLinear(
-  axis: Axis,
-  rect: Rect,
-  spacing: number,
-  crossAlign: HAlign | VAlign,
-  sizes: Size[],
-  flexBase: (number | null)[],
-): Rect[] {
-  const n = sizes.length
-  const out: Rect[] = new Array(n)
-  const gaps = Math.max(0, n - 1) * Math.max(0, spacing)
-
-  const mainAvail = axis === "horizontal" ? rect.w : rect.h
-  const crossAvail = axis === "horizontal" ? rect.h : rect.w
-
-  let baseSum = 0
-  let flexCount = 0
-  for (let i = 0; i < n; i++) {
-    if (flexBase[i] != null) {
-      baseSum += flexBase[i]!
-      flexCount++
-    } else {
-      const size = sizes[i]
-      if (size) {
-        baseSum += axis === "horizontal" ? size.w : size.h
-      }
-    }
-  }
-
-  const leftover = Math.max(0, mainAvail - baseSum - gaps)
-  const per = flexCount > 0 ? Math.floor(leftover / flexCount) : 0
-  let rem = flexCount > 0 ? leftover - per * flexCount : 0
-
-  const crossOffset = (childCross: number) => {
-    if (crossAlign === "center") return Math.floor((crossAvail - childCross) / 2)
-    if ((crossAlign === "trailing" && axis === "vertical") || (crossAlign === "bottom" && axis === "horizontal"))
-      return Math.max(0, crossAvail - childCross)
-    return 0
-  }
-
-  let pos = 0
-  for (let i = 0; i < n; i++) {
-    const s = sizes[i]
-    if (!s) continue
-    const baseMain = flexBase[i] ?? (axis === "horizontal" ? s.w : s.h)
-    const flexExtra = flexBase[i] != null ? per + (rem > 0 ? (rem--, 1) : 0) : 0
-    const wantMain = baseMain + flexExtra
-    const childCross = Math.min(crossAvail, axis === "horizontal" ? s.h : s.w)
-    const remaining = Math.max(0, mainAvail - pos)
-    const takeMain = Math.min(wantMain, remaining)
-    const cs = crossOffset(childCross)
-
-    out[i] =
-      axis === "horizontal"
-        ? { x: rect.x + pos, y: rect.y + cs, w: Math.max(0, takeMain), h: Math.max(0, childCross) }
-        : { x: rect.x + cs, y: rect.y + pos, w: Math.max(0, childCross), h: Math.max(0, takeMain) }
-
-    pos += takeMain
-    if (i < n - 1) pos += spacing
-
-    if (pos >= mainAvail) {
-      for (let j = i + 1; j < n; j++) {
-        out[j] =
-          axis === "horizontal"
-            ? { x: rect.x + mainAvail, y: rect.y, w: 0, h: 0 }
-            : { x: rect.x, y: rect.y + mainAvail, w: 0, h: 0 }
-      }
-      break
-    }
-  }
-
-  return out
-}

package/src/motion-value.ts

@@ -1,335 +0,0 @@
-// motion-value.ts - Generic MotionValue<T> with adapters and animate()
-
-import type { ColorLike, ColorValue } from "./render/surface.js"
-import { parseColor } from "./render/surface.js"
-import { idxToRGB, clamp255 } from "./render/color-utils.js"
-import { DEFAULTS, fromDurationBounce, stepSpring1D, type SpringConfig } from "./spring-physics.js"
-import { colorLikeToRGB } from "./spring.js"
-
-// ---- Types ----
-
-export type SpringOptions = SpringConfig & { maxDt?: number }
-export type Unsubscribe = () => void
-
-export interface AnimationControls {
-	readonly time: number
-	readonly speed: number
-	isRunning(): boolean
-	play(): void
-	pause(): void
-	stop(): void // complete & settle
-	cancel(): void // cancel and keep current value
-	seek(t: number): void
-	finished: Promise<void>
-}
-
-export interface Adapter<T> {
-	toArray(v: T): number[]
-	fromArray(a: ReadonlyArray<number>): T
-	clamp?(a: number[]): number[]
-	equals?(a: T, b: T): boolean
-}
-
-export interface MotionValue<T> {
-	get(): T
-	set(next: T): void
-	setTarget(next: T): void
-	getVelocity(): T
-	onChange(fn: (v: T) => void): Unsubscribe
-	onSettle(fn: () => void): Unsubscribe
-	animate(to: T, options?: SpringOptions): AnimationControls
-	stop(): void
-	destroy(): void
-}
-
-export interface ColorMotionValue extends MotionValue<ColorValue> {
-	animate(to: ColorLike | ColorValue, options?: SpringOptions): AnimationControls
-}
-
-// ---- Built-in adapters ----
-
-export const numberAdapter: Adapter<number> = {
-	toArray: (n) => [n],
-	fromArray: (a) => a[0] ?? 0,
-	clamp: (a) => a,
-	equals: (a, b) => Object.is(a, b),
-}
-
-export const rgbAdapter: Adapter<ColorValue> = {
-	toArray: (c) => [
-		typeof c === "number" ? idxToRGB(c).r : c.r,
-		typeof c === "number" ? idxToRGB(c).g : c.g,
-		typeof c === "number" ? idxToRGB(c).b : c.b,
-	],
-	fromArray: (a) => ({ r: clamp255(a[0] ?? 0), g: clamp255(a[1] ?? 0), b: clamp255(a[2] ?? 0) }),
-	clamp: (a) => [clamp255(a[0] ?? 0), clamp255(a[1] ?? 0), clamp255(a[2] ?? 0)],
-	equals: (a, b) =>
-		typeof a === "number" || typeof b === "number"
-			? JSON.stringify(colorLikeToRGB(a as any)) === JSON.stringify(colorLikeToRGB(b as any))
-			: a.r === b.r && a.g === b.g && a.b === b.b,
-}
-
-// ---- Adapter registry ----
-
-type AdapterEntry = {
-	test: (value: unknown) => boolean
-	create: (value: any) => Adapter<any>
-	normalize?: (value: any) => any
-}
-
-const ADAPTERS: AdapterEntry[] = []
-
-export function registerAdapter(entry: AdapterEntry) {
-	ADAPTERS.unshift(entry)
-}
-
-function isColorObject(x: any): x is { r: number; g: number; b: number } {
-	return x && typeof x === "object" && typeof x.r === "number" && typeof x.g === "number" && typeof x.b === "number"
-}
-
-function isColorLike(v: unknown): v is ColorLike {
-	if (isColorObject(v)) return true
-	if (typeof v === "string" || typeof v === "number") {
-		const parsed = parseColor(v as any)
-		return typeof parsed === "number" || isColorObject(parsed)
-	}
-	return false
-}
-
-// Register built-in adapters
-registerAdapter({
-	test: (v) => isColorLike(v),
-	create: () => rgbAdapter,
-	normalize: (v) => colorLikeToRGB(v as ColorLike),
-})
-registerAdapter({
-	test: (v) => typeof v === "number",
-	create: () => numberAdapter,
-})
-
-// ---- Frameloop (Node-friendly setTimeout-based) ----
-
-type Tickable = () => boolean // keep ticking?
-const tickers = new Set<Tickable>()
-let timer: NodeJS.Timeout | null = null
-
-function pump() {
-	const copy = Array.from(tickers)
-	for (const t of copy) {
-		const keep = t()
-		if (!keep) tickers.delete(t)
-	}
-	if (tickers.size === 0 && timer) {
-		clearTimeout(timer)
-		timer = null
-	} else {
-		// aim ~60fps
-		timer = setTimeout(pump, 16)
-	}
-}
-
-function ensureLoop() {
-	if (!timer) timer = setTimeout(pump, 16)
-}
-
-// ---- AnimationControls implementation ----
-
-class AnimationControlsImpl implements AnimationControls {
-	private _running = false
-	private _resolve!: () => void
-	finished: Promise<void> = new Promise<void>((res) => (this._resolve = res))
-	time = 0
-	speed = 1
-	isRunning(): boolean {
-		return this._running
-	}
-	play(): void {
-		if (!this._running) {
-			this._running = true
-		}
-	}
-	pause(): void {
-		this._running = false
-	}
-	stop(): void {
-		this._running = false
-		this._resolve()
-	}
-	cancel(): void {
-		this._running = false
-	}
-	seek(t: number): void {
-		this.time = Math.max(0, t)
-	}
-}
-
-// ---- MotionValue implementation ----
-
-class MotionValueImpl<T> implements MotionValue<T> {
-	private adapter: Adapter<T>
-	private opts: Required<SpringOptions>
-	private x: number[]
-	private v: number[]
-	private target: number[]
-	private last: number | undefined
-	private changeSubs = new Set<(v: T) => void>()
-	private settleSubs = new Set<() => void>()
-	private controls?: AnimationControlsImpl
-
-	constructor(initial: T, adapter: Adapter<T>, opts?: SpringOptions) {
-		this.adapter = adapter
-		const base = { ...DEFAULTS, maxDt: 0.1, ...(opts ?? {}) }
-		this.opts = base as Required<SpringOptions>
-		if (this.opts.duration != null) {
-			const derived = fromDurationBounce(this.opts.duration, this.opts.bounce ?? DEFAULTS.bounce)
-			this.opts.frequency = derived.frequency
-			this.opts.dampingRatio = derived.dampingRatio
-		}
-		this.x = adapter.toArray(initial)
-		this.v = this.x.map(() => 0)
-		this.target = this.x.slice()
-	}
-
-	get(): T {
-		return this.adapter.fromArray(this.x)
-	}
-	set(next: T): void {
-		this.x = this.adapter.toArray(next)
-		if (this.adapter.clamp) this.x = this.adapter.clamp(this.x)
-		this.v = this.v.map(() => 0)
-		this.target = this.x.slice()
-		this.emitChange()
-	}
-	setTarget(next: T): void {
-		this.target = this.adapter.toArray(next)
-		if (this.adapter.clamp) this.target = this.adapter.clamp(this.target)
-	}
-	getVelocity(): T {
-		return this.adapter.fromArray(this.v)
-	}
-	onChange(fn: (v: T) => void): Unsubscribe {
-		this.changeSubs.add(fn)
-		return () => this.changeSubs.delete(fn)
-	}
-	onSettle(fn: () => void): Unsubscribe {
-		this.settleSubs.add(fn)
-		return () => this.settleSubs.delete(fn)
-	}
-
-	animate(to: T, options?: SpringOptions): AnimationControls {
-		this.setTarget(to)
-		this.opts = { ...this.opts, ...(options ?? {}) } as Required<SpringOptions>
-		if (this.opts.duration != null) {
-			const derived = fromDurationBounce(this.opts.duration, this.opts.bounce ?? DEFAULTS.bounce)
-			this.opts.frequency = derived.frequency
-			this.opts.dampingRatio = derived.dampingRatio
-		}
-		this.controls?.cancel()
-		const controls = new AnimationControlsImpl()
-		controls.play()
-		this.controls = controls
-		this.last = undefined
-
-		const tick = () => {
-			if (!controls.isRunning()) return false
-			const now = Date.now()
-			const last = this.last ?? now
-			const dt = Math.max(0, Math.min(this.opts.maxDt ?? 0.1, (now - last) / 1000))
-			this.last = now
-			const { frequency: f, dampingRatio: z, epsilon, bounce } = this.opts
-			let settled = true
-			for (let i = 0; i < this.x.length; i++) {
-				const prevX = this.x[i]
-				let { x: nextX, v: nextV } = stepSpring1D(prevX, this.v[i], this.target[i], dt, f!, z!)
-				if ((bounce ?? DEFAULTS.bounce) <= 0) {
-					const crossed = (prevX - this.target[i]) * (nextX - this.target[i]) <= 0
-					if (crossed) {
-						nextX = this.target[i]
-						nextV = 0
-					}
-				}
-				this.x[i] = nextX
-				this.v[i] = nextV
-				if (
-					!(
-						Math.abs(this.x[i] - this.target[i]) < (epsilon ?? DEFAULTS.epsilon!) &&
-						Math.abs(this.v[i]) < (epsilon ?? DEFAULTS.epsilon!)
-					)
-				) {
-					settled = false
-				}
-			}
-			if (this.adapter.clamp) this.x = this.adapter.clamp(this.x)
-			this.emitChange()
-			if (settled) {
-				this.x = this.target.slice()
-				this.v = this.v.map(() => 0)
-				this.emitChange()
-				this.emitSettle()
-				controls.stop()
-				return false
-			}
-			return true
-		}
-		tickers.add(tick)
-		ensureLoop()
-		return controls
-	}
-
-	stop(): void {
-		this.controls?.stop()
-	}
-	destroy(): void {
-		this.changeSubs.clear()
-		this.settleSubs.clear()
-		this.controls?.cancel()
-	}
-
-	private emitChange() {
-		const v = this.get()
-		this.changeSubs.forEach((fn) => fn(v))
-	}
-	private emitSettle() {
-		this.settleSubs.forEach((fn) => fn())
-	}
-}
-
-class ColorMotionValueImpl extends MotionValueImpl<ColorValue> implements ColorMotionValue {
-	override animate(to: ColorLike | ColorValue, options?: SpringOptions): AnimationControls {
-		const target =
-			typeof to === "string" || typeof to === "number" ? colorLikeToRGB(to as ColorLike) : (to as ColorValue)
-		return super.animate(target, options)
-	}
-}
-
-// ---- Factory ----
-
-export function motionValue(initial: number, opts?: SpringOptions & { adapter?: Adapter<number> }): MotionValue<number>
-export function motionValue(
-	initial: ColorLike,
-	opts?: SpringOptions & { adapter?: Adapter<ColorValue> },
-): ColorMotionValue
-export function motionValue<T>(initial: T, opts?: SpringOptions & { adapter?: Adapter<T> }): MotionValue<T>
-export function motionValue(initial: any, opts?: SpringOptions & { adapter?: Adapter<any> }): MotionValue<any> {
-	if (opts?.adapter) {
-		const norm = opts.adapter.fromArray(opts.adapter.toArray(initial))
-		return new MotionValueImpl(norm, opts.adapter, opts)
-	}
-	for (const entry of ADAPTERS) {
-		if (entry.test(initial)) {
-			const adapter = entry.create(initial)
-			const normalized = entry.normalize ? entry.normalize(initial) : adapter.fromArray(adapter.toArray(initial))
-			if (adapter === rgbAdapter) return new ColorMotionValueImpl(normalized as ColorValue, adapter, opts)
-			return new MotionValueImpl(normalized, adapter, opts)
-		}
-	}
-	throw new Error("No adapter found for initial value. Provide { adapter } explicitly.")
-}
-
-// ---- Top-level animate helper ----
-
-export function animate<T>(mv: MotionValue<T>, to: T, opts?: SpringOptions): AnimationControls
-export function animate(mv: ColorMotionValue, to: ColorLike | ColorValue, opts?: SpringOptions): AnimationControls
-export function animate(mv: any, to: any, opts?: SpringOptions): AnimationControls {
-	return mv.animate(to as any, opts)
-}

package/src/present/display.ts

@@ -1,206 +0,0 @@
-import { Palette, Surface, type Surface as SurfaceType } from "../render/surface.js"
-import { diffFrames, type RunWriter } from "../render/diff.js"
-import { FullscreenWriter } from "./writers/fullscreen.js"
-import { LineDiffWriter } from "./writers/inline.js"
-import type { View } from "../ui/core/view.js"
-import { ANSI, Terminal } from "../ansi.js"
-import type { TerminalBackend } from "../runtime/backend_node.js"
-import { Effect } from "effect"
-import { geometryStore } from "../ui/core/geometry-store.js"
-
-export interface DisplayRenderer {
-  start(): void
-  draw(view: View): void
-  resize(cols: number, rows: number): void
-  end(): void
-}
-
-abstract class BaseRenderer implements DisplayRenderer {
-  protected palette = new Palette()
-  protected prev?: SurfaceType
-  protected next?: SurfaceType
-
-  constructor(protected backend: TerminalBackend) {}
-  abstract start(): void
-  abstract end(): void
-  abstract makeWriter(): RunWriter
-
-  protected ensureFrames(cols: number, rows: number) {
-    const needNew =
-      !this.prev ||
-      !this.next ||
-      this.prev.w !== cols ||
-      this.prev.h !== rows ||
-      this.next.w !== cols ||
-      this.next.h !== rows
-    if (needNew) {
-      this.prev = new Surface(cols, rows, { palette: this.palette })
-      this.next = new Surface(cols, rows, { palette: this.palette })
-      this.prev.clear(0)
-      this.next.clear(0)
-    }
-  }
-
-  protected swap() {
-    const t = this.prev!
-    this.prev = this.next!
-    this.next = t
-  }
-
-  draw(view: View): void {
-    const { cols, rows } = this.backend.size()
-    this.ensureFrames(cols, rows)
-
-    // render into the "next" frame
-    this.next?.clear(0)
-    geometryStore.beginFrame()
-    view.render(this.next!, this.palette, { x: 0, y: 0, w: cols, h: rows })
-    geometryStore.endFrame()
-
-    const writer = this.makeWriter()
-    diffFrames(this.prev!, this.next!, writer)
-    this.backend.write(writer.flush())
-
-    // swap for next frame
-    this.swap()
-  }
-
-  resize(_c: number, _r: number): void {
-    // Clear terminal and force full rerender
-    this.backend.write(Terminal.clearAndHome) // clear screen + move to top-left
-    delete (this as any).prev
-    delete (this as any).next
-  }
-}
-
-export class FullscreenRenderer extends BaseRenderer {
-  /**
-   * Create a fullscreen renderer. Kept as an Effect to align with inline
-   * and allow future async setup without changing call sites.
-   */
-  static make(backend: TerminalBackend) {
-    return Effect.sync(() => new FullscreenRenderer(backend))
-  }
-  start(): void {
-    this.backend.enterFullscreen()
-  }
-  end(): void {
-    this.backend.exitFullscreen()
-  }
-  makeWriter(): RunWriter {
-    return new FullscreenWriter(this.palette)
-  }
-}
-
-export class InlineRenderer extends BaseRenderer {
-  private writer = new LineDiffWriter(this.palette)
-  private baseRow: number | undefined
-  private skipDiff = false
-  private lastPrintedHeight = 1
-
-  /**
-   * Create an inline renderer anchored to the current cursor row.
-   */
-  static make(backend: TerminalBackend) {
-    return Effect.promise(() => backend.getCursorPosition()).pipe(
-      Effect.catchAll(() => Effect.succeed({ row: process.stdout.rows || 24, col: 1 })),
-      Effect.map((pos) => {
-        const r = new InlineRenderer(backend)
-        r.setBaseRow(Math.max(0, (pos.row | 0) - 1))
-        return r
-      }),
-    )
-  }
-
-  setBaseRow(n: number) {
-    this.baseRow = Math.max(0, n | 0)
-  }
-
-  start(): void {
-    this.backend.hideCursor()
-  }
-  end(): void {
-    const topRow = this.baseRow ?? 0
-    const nextRow1 = Math.max(1, topRow + this.lastPrintedHeight)
-    this.backend.write(ANSI.cursor.to(nextRow1 + 1, 1))
-    this.backend.showCursor()
-  }
-  makeWriter(): RunWriter {
-    return this.writer
-  }
-
-  // Override resize to clear screen and reset base row for inline mode
-  override resize(c: number, r: number): void {
-    // Clear entire screen, scrollback buffer, and move cursor to top-left
-    this.backend.write(ANSI.screen.clearScrollback + Terminal.clearAndHome)
-    // Reset base row to start from top
-    this.baseRow = 0
-    // Force full redraw on next draw
-    this.skipDiff = true
-    // Call parent to clear surfaces
-    super.resize(c, r)
-  }
-
-  // Override draw to support inline base-row anchoring and scroll-up
-  override draw(view: View): void {
-    const { cols, rows } = this.backend.size()
-    this.ensureFrames(cols, rows)
-
-    let baseRow = this.baseRow ?? 0
-
-    const measured = view.measure(cols, rows)
-    const renderW = Math.max(1, Math.min(cols, measured.w || 0))
-    const renderH = Math.max(1, Math.min(rows, measured.h || 0))
-
-    // Render into the "next" frame (clamp to measured size so we don't fill the viewport)
-    this.next?.clear(0)
-    geometryStore.beginFrame()
-    view.render(this.next!, this.palette, { x: 0, y: 0, w: renderW, h: renderH })
-    geometryStore.endFrame()
-
-    // Determine content footprint
-    const bounds = this.next?.contentBounds()
-    const contentH = Math.max(1, (bounds?.h ?? 0) | 0)
-    this.lastPrintedHeight = contentH
-
-    // If bottom would overflow viewport, scroll up and reduce baseRow
-    const bottom1 = baseRow + contentH
-    if (bottom1 > rows) {
-      const scroll = bottom1 - rows
-      if (scroll > 0) {
-        this.backend.write(ANSI.scroll.up(scroll))
-        baseRow = Math.max(0, baseRow - scroll)
-      }
-    }
-
-    // Inform writer of base row for absolute addressing
-    this.writer.setBaseRow?.(baseRow)
-
-    // If we need to skip diff, render directly
-    if (this.skipDiff) {
-      // Position cursor at base row
-      this.backend.write(ANSI.cursor.to(baseRow + 1, 1))
-      // Just render what we have in the surface (viewport content)
-      const output = this.next?.buildStyledLines({ x: 0, y: 0, w: this.next?.w ?? 0, h: contentH }, this.palette)
-      this.backend.write((output ?? []).join("\n"))
-      this.skipDiff = false
-    } else {
-      // Normal diff and flush
-      diffFrames(this.prev!, this.next!, this.writer)
-      this.backend.write(this.writer.flush())
-    }
-
-    // swap for next frame and advance baseline for subsequent renders
-    this.swap()
-    this.baseRow = baseRow
-  }
-}
-
-export type RendererMode = "fullscreen" | "inline"
-
-export class TerminalRenderer {
-  private constructor() {}
-  static make(mode: RendererMode, backend: TerminalBackend) {
-    return mode === "inline" ? InlineRenderer.make(backend) : FullscreenRenderer.make(backend)
-  }
-}

package/src/present/writers/fullscreen.ts

@@ -1,58 +0,0 @@
-import type { RunWriter } from "../../render/diff.js"
-import type { Palette } from "../../render/surface.js"
-import { displayWidth } from "../../render/measure.js"
-import { ANSI } from "../../ansi.js"
-
-class ChunkBuilder {
-  private parts: string[] = []
-  push(s: string) {
-    if (s) this.parts.push(s)
-  }
-  concat() {
-    const out = this.parts.join("")
-    this.parts = []
-    return out
-  }
-}
-
-export class FullscreenWriter implements RunWriter {
-  private out = new ChunkBuilder()
-  private curRow = -1
-  private curCol = -1
-  private curStyle = -1
-  private rows = 0
-
-  constructor(private palette: Palette) {}
-
-  begin(vp: { cols: number; rows: number }) {
-    this.rows = vp.rows
-  }
-
-  run(row: number, col: number, styleId: number, text: string): void {
-    if (row !== this.curRow || col !== this.curCol) {
-      this.out.push(ANSI.cursor.to(row + 1, col + 1))
-      this.curRow = row
-      this.curCol = col
-    }
-    if (this.curStyle !== styleId) {
-      this.out.push(this.palette.sgr(styleId))
-      this.curStyle = styleId
-    }
-    this.out.push(text)
-    this.curCol += displayWidth(text) // fix for wide glyphs
-  }
-
-  end(): void {
-    if (this.curStyle !== -1) this.out.push(ANSI.reset)
-    // park cursor bottom-left (optional)
-    this.out.push(ANSI.cursor.to(this.rows, 1))
-  }
-
-  flush(): string {
-    const s = this.out.concat()
-    // reset tracked cursor/style to unknown so next frame emits properly
-    this.curRow = this.curCol = -1
-    this.curStyle = -1
-    return s
-  }
-}