proposals

type Action int

type AppliedKeyError struct {
	// Groups holds one group for each refused key. The groups are in the
	// order of their lowest pending ID.
	Groups []AppliedKeyGroup
}

type AppliedKeyGroup struct {
	// Applied holds the IDs of the applied proposals with the key, in ID
	// order. An old ledger can hold more than one.
	Applied []int64
	// Pending holds the IDs of the selected pending proposals with the
	// key, in ID order.
	Pending []int64
}

type FileObservation struct {
	Exists bool
	SHA256 [32]byte
}

type Fingerprint struct {
	ID        int64
	Signature string
	Rule      string
	Note      string
	Regions   []string
}

type Ledger struct {
	// Pending, Applied and Dismissed hold the proposals by state, in
	// ascending ID order.
	Pending, Applied, Dismissed []model.Proposal
	// Superseded holds the proposals whose pins a prune removed, in
	// ascending ID order. They are read-only history: no decision can
	// change them, so Health does not cover them.
	Superseded []model.Proposal
	// Health holds evidence-health advisories by proposal ID.
	Health map[int64]report.ProposalHealth
	// HealthErr holds the advisory failure; Health is then empty.
	HealthErr error
	// Evidence holds the full cited findings by finding ID. A cited ID
	// that is missing aged out of the index.
	Evidence map[int64]model.Finding
	// EvidenceErr holds the evidence read failure.
	EvidenceErr error
	// Write is the current distill.write gate.
	Write bool
	// WriteErr holds the config read failure; Write is then false.
	WriteErr error
	// ObservedAt is the time of the snapshot.
	ObservedAt time.Time
}

type Ledgerer interface {
	ProposalsByIDs(ids []int64) ([]model.Proposal, error)
	// Proposals returns the rows of one status. Apply and reconcile read
	// the applied rows, because Pins blocks a pin key that more than one
	// applied row records.
	Proposals(status string) ([]model.Proposal, error)
	SetProposalStatus(ids []int64, to string) (int, error)
}

type Preview struct {
	Action Action
	// Proposals holds the eligible selected proposals in ID order.
	Proposals []model.Proposal
	// Prints holds their fingerprints, parallel to Proposals.
	Prints []Fingerprint
	// Ineligible holds requested IDs that are no longer pending.
	Ineligible []int64
	// Write is the distill.write gate at preview time (apply only).
	Write bool
	// YAML is the pin block that apply inserts at the head of the
	// `pin:` list.
	YAML string
	// Target is the pin file path relative to the root.
	Target string
	// Lessons is the pin file observation (apply only).
	Lessons FileObservation
	// LessonsErr holds the pin file guard failure of an apply preview
	// taken with the gate off, for example a symbolic link. That
	// preview writes nothing, so the failure does not stop the YAML
	// block; Lessons is then zero and Commit refuses the preview.
	LessonsErr error
	// AlreadyPinned holds selected IDs whose pin already exists. No
	// applied proposal records such a pin, because the preview refuses
	// that case first (ErrAppliedKey).
	AlreadyPinned []int64
}

type Result struct {
	Action Action
	// FileWritten is true when the pin file changed.
	FileWritten bool
	// FileErr holds the pin file failure.
	FileErr error
	// Moved holds the IDs whose ledger state changed.
	Moved []int64
	// NotMoved holds the selected IDs whose ledger state did not change.
	NotMoved []int64
	// LedgerErr holds the ledger failure.
	LedgerErr error
}

type SharedKeyError struct {
	// Groups holds the IDs of each shared key in ID order. The groups
	// are in the order of their lowest ID.
	Groups [][]int64
}