proc

type Command struct {
	// Executable is a path, or a name resolved on PATH.
	Executable string
	// Arguments follow the executable in the argument vector.
	Arguments []string
	// Directory is the working directory; empty means the caller's.
	Directory string
	// Environment replaces the inherited environment when non-nil.
	Environment []string
	// ExtraEnvironment is appended to the environment the child receives,
	// inherited or replaced, so a caller adds a variable without reading the
	// process environment itself.
	ExtraEnvironment []string
	// Stdin is the child's standard input; nil means none.
	Stdin io.Reader
	// Stdout receives standard output. When nil it is captured into
	// [Result.Stdout] (unbounded, like exec.Cmd.Output), unless StdoutPipe
	// is set on a started process.
	Stdout io.Writer
	// Stderr receives standard error. When nil it is captured, bounded by the
	// launcher's diagnostic limit, into [Result.Stderr] and [ExitError],
	// whose message then carries it. A caller whose child's diagnostics may
	// hold secrets passes io.Discard to keep them out of every error.
	Stderr io.Writer
	// StdoutPipe exposes standard output as [Process.Stdout] on a started
	// process. Read it to the end before Wait.
	StdoutPipe bool
	// Terminal attaches the child to a new pseudo-terminal of this size, in
	// its own session. Stdin, Stdout and Stderr must be nil: the terminal is
	// all three, read and written through [Process.Terminal].
	Terminal *TerminalSize
}

type ExitError struct {
	Executable string
	Code       int
	Stderr     []byte
	// contains filtered or unexported fields
}

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

type HostLauncherOption func(launcher *HostLauncher) error

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

type ILauncher interface {
	// Run starts command, waits for it and returns its structured result.
	Run(ctx context.Context, command Command) (Result, error)
	// Start launches command and returns the running process, which the
	// caller must Wait for.
	Start(ctx context.Context, command Command) (*Process, error)
	// LookPath resolves an executable name the way Run would.
	LookPath(name string) (string, error)
}

type IPressureSource interface {
	// Arm writes the trigger; a refused write is ErrInvalidTrigger.
	Arm(trigger string) error
	// Wait blocks until the trigger fires, ctx ends (its error), or the
	// file fails.
	Wait(ctx context.Context) error
	Close() error
}

type Pressure struct {
	Some PressureLine
	Full PressureLine
}

type PressureKind string

type PressureLine struct {
	Avg10  float64
	Avg60  float64
	Avg300 float64
	Total  time.Duration
}

type PressureResource string

type PressureTrigger struct {
	Kind   PressureKind
	Stall  time.Duration
	Window time.Duration
}

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

type Result struct {
	// ExitCode is the child's exit status, or -1 if it was killed by a
	// signal or never ran.
	ExitCode int
	// Stdout is captured standard output when Command.Stdout was nil.
	Stdout []byte
	// Stderr is captured standard error when Command.Stderr was nil.
	Stderr []byte
	// StderrTruncated reports that captured standard error exceeded the
	// diagnostic limit and only its prefix was kept.
	StderrTruncated bool
}

type TerminalSize struct {
	Rows    uint16
	Columns uint16
}