chat

type Act struct {
	Kind ActKind
	Text string
	I    int
	Now  bool
	K    uint32
}

type ActKind uint8

type Bar struct {
	Vertical bool
	X, Y     float32
	Len      float32
	// Content is the content's length, View how much of it shows, Pos how far it is scrolled.
	Content, View, Pos float32
}

type BarID struct {
	Thread bool
	S, K   int
}

type Block struct {
	Text     string
	Rect     Rect4
	Selected [2]int
	HasSel   bool
}

type Bot struct {
	Name  string
	Color Rgba
}

type BoxBar struct {
	ID  [2]int
	Bar Bar
}

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

type Fetch struct {
	Kind  FetchKind
	Bytes []byte
}

type FetchKind uint8

type Frag struct {
	Texts     []TextBox
	Shapes    []Shape
	Copy      []Tok
	Scrollers []Scroller
	Hits      []HitRect
}

type HL struct {
	B0, B1 int
	Color  Rgba
	Em     bool
}

type Hit struct {
	Kind    HitKind
	Link    string
	Section int
	Act     Act
	Pos     Pos
}

type HitKind uint8

type HitRect struct {
	R   Rect4
	Act Act
}

type ImageKind uint8

type ImageState struct {
	Kind ImageKind
	W, H float32
}

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

type Link struct {
	B0, B1 int
	URL    string
}

type Loader func(src string) Fetch

type Look struct {
	Size, LH float32
	Color    Rgba
	Weight   float32
	Family   string
}

type NumLine struct {
	N    int64
	HasN bool
	Gap  bool
	Text string
}

type Painter struct {

	// Images is shared with the thread (it lays images out by their size).
	Images *Images

	// Frames counts painted frames, for the benchmark.
	Frames uint64
	// Time is in seconds, for the live step's shimmer (a 2 s loop, as `@keyframes flow`).
	Time float32
	// Hover is the scrollbar whose thumb is under the pointer (it darkens).
	Hover    BarID
	HasHover bool
	// contains filtered or unexported fields
}

type Part int

type Pos struct {
	Section, Text, Byte int
}

type Rect4 [4]float32

type Rgba = color.NRGBA

type Scroller struct {
	// Clip is where the content shows (x, y, w, h): the padding box less the bar, which sits just under it.
	Clip Rect4
	// Content is the scrollable width.
	Content float32
	// Shapes scroll with the content (a table's header fill and row rules).
	Shapes []Shape
}

type Section struct {
	Y, H float32
	Frag *Frag
	// AnswerTok is where the answer's copy tokens start (a select-all inside `.ans`).
	AnswerTok    int
	HasAnswerTok bool
	// AnswerAt is where the answer's texts, shapes and scrolling boxes start (it fades in on its own).
	AnswerAt    [3]int
	HasAnswerAt bool
	// Images are the answer's images, and stale says one of them changed since it was laid out.
	Images []string
	// contains filtered or unexported fields
}

type Shape struct {
	Kind       ShapeKind
	X, Y, W, H float32
	Radius     [4]float32
	Fill       Rgba
	Stroke     Rgba
	SW         float32
	Src        string // Image: the source; Svg: the document
	Cover      bool   // Image: object-fit: cover (a prompt's thumbnails)
	Pts        [][2]float32
}

type ShapeKind uint8

type Shaper struct {
	*text.Shaper
}

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

type Stage uint8

type Step struct {
	Kind      StepIcon
	Verb      string
	Name, Dir string
	Cmd       string
	Status    string
	Add, Del  int
	Diff, Out string
	Exit      int
	HasExit   bool
	Ms        float64
	HasMs     bool
	// Tag is the demo's own tag ("81 passed"): a check and the words.
	Tag string
	// Lead is what the agent said just before this step, shown above it.
	Lead string
}

type StepIcon uint8

type Tail uint8

type TextBox struct {
	Layout *text.Layout
	X, Y   float32
	// Text is the text as laid out, for copying (inline boxes are not in it). Empty for
	// drawn-only text (list markers, the code block's language tag, an ellipsis).
	Text  string
	Links []Link
	// Clip is `overflow: auto` of the box it sits in, in the same coordinates as X, Y.
	Clip *Rect4
	// Shimmer: the live step's moving highlight (`.work .on` in page.html).
	Shimmer bool
	// Cell: a table cell: a double or triple click stays inside it.
	Cell bool
	// Scr is the box that scrolls it sideways: an index into Frag.Scrollers plus one (0: none).
	Scr int
}

type Thread struct {
	Width    float32
	Who      string
	Color    Rgba
	Sections []Section
	Height   float32
	// Selection is the anchor and focus; Tail is what it takes in after its last box.
	Sel    [2]Pos
	HasSel bool
	Tail   Tail
	// ImageState and ImageRule: what the layout knows of an image, and where one may load from.
	ImageState func(string) ImageState
	ImageRule  md.ImageFn

	// Session is the session shown (its id in the state message), for stepsUser.
	Session   uint64
	HideSteps bool
	// Tool is the tool, for its logo over each answer.
	Tool string

	// Copied is the code block just copied (its button says "Copied" a moment).
	Copied *string
	// ViewH is the thread's visible height.
	ViewH float32
	// Relayouts counts section layouts made since the thread was created (for the tests and the benchmark).
	Relayouts int
	// HScroll is how far each sideways-scrolling box is scrolled, by (section, scroller). A
	// section laid out again starts at 0, as the page's re-rendered answer does.
	HScroll map[[2]int]float32
	// Fresh is `.ans.fresh`: the section whose answer just arrived, and when (the painter's clock).
	FreshSection int
	FreshAt      float32
	HasFresh     bool

	// ExtraBottom is room kept under the last turn (the reply circle sits over the thread's corner).
	ExtraBottom float32
	// Ticking: a command is running: its time counts, so the app lays the thread out again each second.
	Ticking bool
	// contains filtered or unexported fields
}

type Tok struct {
	Kind TokKind
	N    int
	S    string
}

type TokKind uint8

type Turn struct {
	Prompt string
	// Images are the prompt's pasted images (URLs the painter's loader can fetch).
	Images []string
	Queued bool
	Steps  []Step
	// Took is how long it worked ("3m 07s"); TookMs the same in ms.
	Took      string
	TookMs    float64
	HasTookMs bool
	// Credits is what the turn cost ("0.09 credits"), when the tool says.
	Credits string
	Stage   Stage
	// Live: the turn running now (working, or waiting on the user).
	Live bool
	// Clock is how long the live turn has gone ("0:12").
	Clock string
	// When the prompt was sent (.me .when).
	When   string
	Status string
	Answer string
	// Waiting: the live turn waits on the user (a question, a permission).
	Waiting bool
	// Stopping: asked to stop or pause, and the tool hasn't said it has yet.
	Stopping bool
	// Restore and Again: its acts row offers Restore (the chat and the folder back to just
	// after this answer) and Try again (the folder back to before this message, which goes
	// again): a checkpoint was kept there and nothing runs.
	Restore, Again bool
}

type Unit uint8