liveview

type ContractReport struct {
	Available bool   `json:"available"`
	Reason    string `json:"reason,omitempty"`

	// Rows is the tally in display order: the contract's five, best-
	// established first, then untagged, then any unknown value. Ordering here
	// rather than in the page keeps the contract's vocabulary in Go, where it
	// is already written down once.
	//
	// When nothing at all carries a grade the five are omitted entirely and
	// only the untagged row survives. That is the honest shape for the state
	// a real machine is most likely in today: five empty bars describe a
	// measurement that was taken, and none was.
	Rows []ContractRow `json:"rows"`

	// Graded and Untagged are records, not rows: graded counts everything
	// carrying any _grade, an unrecognised one included.
	Graded   int `json:"graded"`
	Untagged int `json:"untagged"`
	// Nodes and Edges are the store's own totals, so the panel can say that it
	// counted the whole shelf and not the six hundred nodes on screen.
	Nodes int `json:"nodes"`
	Edges int `json:"edges"`

	// Attention is held and refused together, each with the reason its
	// producer gave. Told apart by Grade, not split into two lists — a reader
	// working through a shelf wants both, and two lists makes it likely only
	// one gets rendered.
	Attention []cortexdb.GradedRecord `json:"attention"`
	Truncated bool                    `json:"truncated,omitempty"`
	// Total is everything held or refused, whether or not it is in Attention.
	Total int `json:"total"`

	// At is when this was read, so the panel can show its own staleness rather
	// than leave a slow number looking like a stuck one.
	At int64 `json:"at"`
}

type ContractRow struct {
	// Grade is the contract value, verbatim — empty for the untagged row, and
	// for an unknown row whatever the producer actually wrote, so the
	// maintainer can go and find it.
	Grade string `json:"grade"`
	Kind  string `json:"kind"`
	Nodes int    `json:"nodes"`
	Edges int    `json:"edges"`
}

type Delta struct {
	Version      int64    `json:"version"`
	AddedNodes   []Node   `json:"added_nodes"`
	RemovedNodes []string `json:"removed_nodes"`
	AddedEdges   []Edge   `json:"added_edges"`
	RemovedEdges []Edge   `json:"removed_edges"`
	// Nodes and Edges are the totals after applying, so the page's counters
	// cannot drift out of step with the brain if a delta is ever missed.
	Nodes int `json:"nodes"`
	Edges int `json:"edges"`
}

type Edge struct {
	Source string `json:"source"`
	Target string `json:"target"`
	Label  string `json:"label"`
}

type Event struct {
	Seq  int64  `json:"seq"`
	At   int64  `json:"at"` // unix milliseconds
	Kind string `json:"kind"`
	Tool string `json:"tool"`
	// Text is the line the ticker shows.
	Text string `json:"text"`
	// Terms are the strings the page lights nodes up by. They are matched
	// loosely against labels and ids rather than joined on node identity: a
	// tool's arguments name things the way a person does ("CortexDB"), and the
	// graph keys them the way a database does ("entity:CortexDB").
	Terms []string `json:"terms,omitempty"`
	// Links are from/to pairs to draw a pulse along, for relation writes.
	Links  [][2]string `json:"links,omitempty"`
	Failed bool        `json:"failed,omitempty"`
}

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

type Message struct {
	Delta *Delta `json:"delta,omitempty"`
	Event *Event `json:"event,omitempty"`
}

type Node struct {
	ID    string `json:"id"`
	Label string `json:"label"`
	Type  string `json:"type"`
}

type Payload struct {
	Version  int64   `json:"version"`
	Nodes    []Node  `json:"nodes"`
	Edges    []Edge  `json:"edges"`
	Events   []Event `json:"events"`
	Source   string  `json:"source"`
	Activity bool    `json:"activity"`
	Interval int64   `json:"interval_ms"`
}

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

type Snapshot struct {
	Version int64  `json:"version"`
	Nodes   []Node `json:"nodes"`
	Edges   []Edge `json:"edges"`
}

type Source struct {
	Describe string
	Read     func(ctx context.Context) ([]Node, []Edge, error)
	// Contract answers the knowledge contract's two questions about this
	// store: how much of it stands on what, and what on it needs a person.
	//
	// Optional, and nil is a legitimate answer rather than an oversight: a
	// source can be a graph that keeps no contract metadata at all — a side
	// graph assembled in memory, say. The panel says so in words instead of
	// drawing an empty chart over it, so nil never reads as "nothing here is
	// graded", which is a different and much more common finding.
	Contract func(ctx context.Context) (ContractReport, error)
	Close    func() error
}