session

type Backend interface {
	StartPromotion(ctx context.Context, req service.StartRequest, h service.Hooks) (service.Drive, error)
	Resume(ctx context.Context, id string, o service.ResumeOpts) (service.Drive, error)
	Abandon(ctx context.Context, id string) ([]string, error)
	List(ctx context.Context, o service.ListOpts) ([]service.Listed, error)
}

type BuildID uint64

type Change struct {
	Kind  ChangeKind
	Build BuildID
	ID    string
	Err   error
	List  []service.Listed
	Lines []string
	// Snap is the entry's own last snapshot, populated only for a Change whose entry Update
	// removes from Controller in the very same call (ChangeDone, ChangeAbandoned) — every other
	// kind leaves the entry live, so a caller can always get a fresher one straight from
	// Controller.Snapshot/BuildSnapshot instead. Without this, a mirroring screen (the flight
	// screen) would have nothing left to mirror the instant a promotion
	// finishes: BuildSnapshot(build) already returns false by the time the Change reaches it,
	// since withoutEntry has already run, and the screen would be frozen one step short of the
	// true final state forever.
	Snap Snapshot
}

type ChangeKind int

type Config struct {
	// Deadline bounds one build+drive's whole ctx, shared between the StartPromotion/Resume call
	// and every Step call that follows it (one ctx per drive — the time the build
	// itself took counts against the same budget the drive polls against, never a fresh window
	// per Step call, mirroring flight.Model's own deadlineAt one layer up).
	Deadline time.Duration
	// ListEvery is the in-flight listing's own poll cadence (mirrors app.go's old inFlightTick).
	ListEvery time.Duration
	// MinTick floors a Step's own requested wait (service.Tick.Wait) — the same floor
	// flight.Model.minTick already applies, one layer down.
	MinTick time.Duration
	// AbandonWait is the interval between abandon-wait rechecks (mirrors app.go's own
	// abandonWaitInterval).
	AbandonWait time.Duration
	// AbandonTimeout bounds the whole abandon wait for a busy Step to notice its ctx was
	// cancelled (mirrors app.go's own abandonWaitMaxAttempts, expressed as a duration since
	// Config carries durations, not attempt counts) — it does NOT bound Backend.Abandon itself;
	// see AbandonCallTimeout for that. A short value here just means the wait gives up sooner
	// and calls Backend.Abandon anyway (re-observation makes that safe — see Abandon's own doc
	// comment), it never shortens the call itself.
	AbandonTimeout time.Duration
	// AbandonCallTimeout bounds one Backend.Abandon call — a real re-observation (ObserveAll:
	// git ls-remote plus forge PR/check lookups) followed by ClosePR and a DeleteRemoteBranch
	// push, none of which is instant. This is deliberately generous and independent of
	// AbandonTimeout/AbandonWait, which only bound the short busy-Step wait that precedes the
	// call: conflating the two would give a real abandon a 1s deadline and routinely fail
	// it with "context deadline exceeded", sometimes after ClosePR had already run but before
	// DeleteRemoteBranch had a chance to.
	AbandonCallTimeout time.Duration
	// ListTimeout bounds one Backend.List call. Kept equal to internal/app/scope.List (60s, P3
	// #14) — that constant's own doc comment is what actually documents the value;
	// this default exists so a caller that builds a Config directly (every test) still gets it.
	ListTimeout time.Duration
	// Now is the clock. Defaults to time.Now; every test injects a fixed one.
	Now func() time.Time
	// After schedules a message after d — tea.Tick by default. Tests inject a version that
	// fires on request (or immediately) so nothing here ever actually sleeps.
	After func(d time.Duration, f func(time.Time) tea.Msg) tea.Cmd
}

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

type Driver interface {
	Step(ctx context.Context) (service.Tick, error)
	State() engine.PromotionState
	OverrideCINone()
}

type Event interface {
	// contains filtered or unexported methods
}

type LogLine struct {
	At   time.Time
	Text string
}

type Phase int

type Snapshot struct {
	Build          BuildID
	ID             string
	Phase          Phase
	Source, Target string
	Direct         bool

	State    engine.PromotionState
	Statuses []engine.StepStatus
	Done     bool
	Blocked  *engine.BlockedError
	Err      error
	Retry    bool
	Busy     bool

	NextPoll, DeadlineAt time.Time
	Log                  []LogLine
}