updater

type Backuper interface {
	PreUpdate(ctx context.Context, target string) (note string, err error)
}

type Decision struct {
	Action         string
	Kind           string
	Target         string
	Rec            *release.Record // set for apply and wait
	Reason         string
	AvailableMajor string
	FirstSeen      map[string]time.Time // input map plus newly seen candidates, pruned to the manifest
	// Fallback is the yank-back to use when this apply turns out not to be
	// installable (the preflight Decide cannot see). Set only for an apply that
	// replaces a withdrawn running release, and only when that yank-back is allowed.
	Fallback *Decision
}

type Env struct {
	Data        string // absolute data dir
	Version     string // the running version
	Platform    string // "" = this build's platform
	Supervisor  supervisor.Config
	Store       *Store // nil: no stored policy or status (the offline CLI)
	Plugins     PluginSource
	Imports     ImportProbe
	Backups     Backuper // nil blocks the update unless the backup is skipped
	Site        func(ctx context.Context) *time.Location
	DatabaseURL string
	BaseURL     string // "" = DefaultBaseURL
	Log         *slog.Logger
	Now         func() time.Time
}

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

type ImportProbe interface {
	ImportRunning(ctx context.Context) (bool, error)
}

type Input struct {
	Running       string
	RunningRecord *release.Record // for rollback_floor; may be nil
	Manifest      *release.ChannelManifest
	Settings      Settings // effective: defaults and environment applied
	Now           time.Time
	Loc           *time.Location // site timezone for the window; nil = UTC
	Bucket        func(version string) int
	Bad           func(version string) bool   // versions that failed health gating; may be nil
	BadReason     func(version string) string // why a bad version failed; may be nil
	FirstSeen     map[string]time.Time
	// Previous is what a yank-back returns to: the supervisor's previous
	// release, or when PreviousIsBootstrap the bootstrap build's version
	// ("" or not semver when unknown). "" with PreviousIsBootstrap false: none.
	Previous            string
	PreviousIsBootstrap bool
	// Record reads and verifies one release record. Decide memoises it and
	// calls it at most MaxRecordFetches times.
	Record func(version string) (*release.Record, error)
}

type NamedRange struct {
	Kind  string // "plugin" or "theme"
	Name  string
	Range string
}

type PluginSource interface {
	EnabledSDKRanges(ctx context.Context) ([]NamedRange, error)
}

type Querier interface {
	QueryRow(ctx context.Context, sql string, args ...any) pgx.Row
	Exec(ctx context.Context, sql string, args ...any) (pgconn.CommandTag, error)
}

type RunOpts struct {
	DryRun bool   // decide only; nothing is stored or staged
	Apply  string // a named version: the explicit operator route
	Force  bool   // skip the plugin preflight
	// CheckOnly is a dry run whose outcome is stored like a scheduled check:
	// fetch, decide and preflight, never download, stage or switch.
	CheckOnly bool
	// Managed makes a named Apply behave like a scheduled install where it
	// matters to the owner: it waits for a running check instead of giving up,
	// takes the pre-update database backup and stores its outcome whatever it
	// is. The CLI leaves it off.
	Managed bool
	// SkipBackup skips the pre-update backup for this run only.
	SkipBackup bool
}

type Settings struct {
	Mode        string
	Channel     string
	WindowStart *int
	WindowEnd   *int
	Pin         string // "vX.Y" or ""
	DeferDays   int    // 0..MaxDeferDays
}

type Status struct {
	LastCheckAt    *time.Time
	LastResult     string
	Decision       string
	Reason         string
	Target         string
	AvailableMajor string
	FirstSeen      map[string]time.Time
}

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

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