release

type Action string

type Applier interface {
	// Apply materializes a create / update / adopt / reference change.
	Apply(ctx context.Context, change PlannedChange) error
	// Prune deletes a no-longer-desired owned resource, honoring reclaim policy.
	Prune(ctx context.Context, ref types.OwnerRef) error
	// Verify blocks until the given owned resources are healthy (or errors).
	Verify(ctx context.Context, refs []types.OwnerRef) error
	// Revert restores a resource to the pre-image captured before this cast
	// first touched it (via Apply or Prune): a resource that did not exist is
	// deleted, one that did is restored to that prior state. Used only by
	// atomic rollback; must tolerate the change having half-applied or not
	// applied at all.
	Revert(ctx context.Context, ref types.OwnerRef) error
}

type Conflict struct {
	OwnedBy *types.OwnedBy
	Reason  string
}

type DesiredResource struct {
	Ref types.OwnerRef
	// ContentHash optionally lets the planner skip no-op updates. Empty means
	// "always treat as a potential update" (a finer no-op check is a TODO).
	ContentHash string
}

type LiveLookup interface {
	Lookup(ref types.OwnerRef) (LiveState, error)
}

type LiveState struct {
	Exists bool
	// OwnedBy is the OwnedBy stamp found on the live resource, or nil if the
	// resource is unmanaged (exists but carries no release ownership).
	OwnedBy *types.OwnedBy
}

type Options struct {
	// Adopt allows taking over resources that exist but are unmanaged or owned
	// by a different release (the --adopt flag).
	Adopt bool
}

type Plan struct {
	Release   string
	Namespace string
	Changes   []PlannedChange
}

type PlannedChange struct {
	Ref      types.OwnerRef
	Action   Action
	Conflict *Conflict
}

type PreparedCast struct {
	Release *types.Release
	Plan    *Plan
	// Execute applies the prepared change set and returns the final release
	// record (deployed, or failed with the cause). Safe to call from a
	// background goroutine with a detached context.
	Execute func(ctx context.Context, applier Applier) (*types.Release, error)
}

type ReleaseRecords interface {
	Get(ctx context.Context, namespace, name string) (rel *types.Release, found bool, err error)
	Save(ctx context.Context, rel *types.Release) error
}

type ReleaseSpec struct {
	Name           string
	Namespace      string
	Source         types.ReleaseSource
	Manifest       types.RunesetManifest
	Values         map[string]interface{}
	RenderedDigest string
	Resources      []DesiredResource
	Options        Options

	// Detach requests create/update-only async completion (Decision C3). A
	// detach spec whose plan prunes is rejected with ErrDetachWouldPrune.
	Detach bool

	// Atomic opts into rollback-on-failure (Decision D3, Helm parity): if any
	// apply, verify, or prune step fails, every change this revision already
	// made is reverted — creates deleted, updates and prunes restored from
	// their pre-cast state — so the cast lands fully applied or not at all.
	// The release is still recorded `failed` (the rollback is noted in the
	// cause); the default (false) keeps today's leave-as-failed behavior.
	Atomic bool
}