resource

type Activity struct {
	Label string `json:"label"`
	Done  int    `json:"done"`
	Total int    `json:"total"`
}

type Sample struct {
	At int64 `json:"at"` // unix milliseconds

	// RSS is the resident set size in bytes: what the OS actually holds in
	// physical memory for this process. It is the figure that matches Activity
	// Monitor and top, and it covers the CGO allocations (ONNX weights, MuPDF,
	// tree-sitter) that never appear in the Go numbers below.
	RSS uint64 `json:"rss"`

	// HeapInUse is the bytes of live heap objects; GoTotal is all memory the Go
	// runtime currently holds from the OS (heap, stacks, metadata) minus what it
	// has released back. Go returns memory lazily, so RSS routinely sits well
	// above HeapInUse after a spike — that divergence is normal rather than a
	// leak, which is why both are reported instead of one.
	HeapInUse uint64 `json:"heapInUse"`
	GoTotal   uint64 `json:"goTotal"`

	// CPUPercent is top-style: 100 means one core fully saturated, so on a
	// multi-core machine it can legitimately exceed 100.
	CPUPercent float64 `json:"cpuPercent"`

	Goroutines int `json:"goroutines"`
}

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

type Snapshot struct {
	Interval int      `json:"interval"` // milliseconds between samples
	Cores    int      `json:"cores"`
	Uptime   int64    `json:"uptime"` // milliseconds since process start
	Samples  []Sample `json:"samples"`
}

type TurnStats struct {
	DurationMS int64 `json:"durationMs"`
	// CoveredMS is how much of the turn was actually measured. The sampler
	// keeps a four-minute window, so a longer turn reports only the samples
	// still retained, and a turn shorter than two ticks reports none.
	CoveredMS int64 `json:"coveredMs"`
	Samples   int   `json:"samples"`

	RSSMB     float64 `json:"rssMb"`     // last reading
	PeakRSSMB float64 `json:"peakRssMb"` // highest over the turn
	GoHeapMB  float64 `json:"goHeapMb"`  // last reading

	// CPUAvgPercent and CPUMaxPercent are top-style: 100 is one core fully
	// saturated, so both can legitimately exceed 100 on a multi-core machine.
	CPUAvgPercent float64 `json:"cpuAvgPercent"`
	CPUMaxPercent float64 `json:"cpuMaxPercent"`

	Goroutines     int `json:"goroutines"` // last reading
	PeakGoroutines int `json:"peakGoroutines"`

	Cores     int     `json:"cores"`
	HostRAMMB float64 `json:"hostRamMb"` // physical memory on this machine
}