op

type AccessType string

type Action interface {

	// Name returns the action identifier (e.g., "file.link", "template.render").
	Name() string

	// Do executes the action with the given context and resolved slot values.
	//
	// Parameters:
	//   - ctx: execution context
	//   - slots: resolved slot values
	//
	// Returns:
	//   - result: A result for downstream nodes
	//   - undo: undo state for saga rollback
	//   - err: any error encountered during execution
	Do(ctx *Context, slots map[string]any) (Result, UndoState, error)
}

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

type Attempt struct {
	// Number is the 1-based attempt number.
	Number int `json:"number" yaml:"number"`

	// Status is "completed" or "failed".
	Status string `json:"status" yaml:"status"`

	// Error is the error message if the attempt failed.
	Error string `json:"error,omitempty" yaml:"error,omitempty"`

	// Timestamp is when this attempt completed (RFC3339).
	Timestamp string `json:"timestamp" yaml:"timestamp"`
}

type BackoffStrategy string

type BindingConfig struct {
	// Writer is the output destination for immediate receivers (e.g., ui.note).
	Writer io.Writer

	// ProgramName identifies the running tool (e.g., "lore", "writ").
	ProgramName string

	// Color enables ANSI color codes in output.
	Color bool

	// WorkDir is the working directory for providers that operate on files.
	// If empty, providers should default to the current working directory.
	WorkDir string
}

type Collision struct {
	Target            string `json:"target" yaml:"target"`
	Winner            string `json:"winner" yaml:"winner"`
	WinnerLayer       string `json:"winner_layer,omitempty" yaml:"winner_layer,omitempty"`
	WinnerSpecificity int    `json:"winner_specificity,omitempty" yaml:"winner_specificity,omitempty"`
	Loser             string `json:"loser" yaml:"loser"`
	LoserLayer        string `json:"loser_layer,omitempty" yaml:"loser_layer,omitempty"`
	LoserSpecificity  int    `json:"loser_specificity,omitempty" yaml:"loser_specificity,omitempty"`
}

type CompensableAction interface {
	Action

	// Undo performs the compensating action using the state captured by Do.
	//
	// Parameters:
	//   - ctx: execution context
	//   - state: undo state captured by Do
	//
	// Returns:
	//   - err: any error encountered during compensation
	Undo(ctx *Context, undo UndoState) error
}

type Context struct {
	context.Context // https://pkg.go.dev/context

	// Catalog is the resource catalog for the current execution session.
	// The action layer uses it to shadow Resource results after dispatch.
	// Nil when running without catalog integration (e.g., tests).
	Catalog *ResourceCatalog

	// Data holds tool-provided context: template variables, SOPS config,
	// identities, segment maps, etc. Each tool populates this before
	// calling GraphExecutor.Run().
	Data map[string]any

	// DryRun prevents filesystem modifications when true.
	DryRun bool

	// Graph is the graph being executed. Flow actions use this to look up
	// phases referenced by their slots (e.g., gather body, choose branch).
	Graph *Graph

	// NodeID is the ID of the currently executing node. Flow actions use
	// this to identify themselves (e.g., gather uses it for proxy context).
	NodeID string

	// Platform provides platform abstractions (package manager, service
	// manager) to action providers. Nil when running in environments
	// where host access is not needed (e.g., pure data transforms).
	Platform *Platform

	// Writer receives user-facing output messages.
	Writer io.Writer
}

type Edge struct {
	From string `json:"from" yaml:"from"`
	To   string `json:"to" yaml:"to"`
}

type Encoder interface {
	Encode(v any) error
}

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

type Graph struct {
	// Version is the graph format version.
	Version string `json:"version" yaml:"version"`

	// Tool identifies which tool created this graph ("writ" or "lore").
	Tool string `json:"tool" yaml:"tool"`

	// Timestamp is when the graph was created/executed.
	Timestamp time.Time `json:"timestamp" yaml:"timestamp"`

	// State is the execution state (pending, executed, failed).
	State GraphState `json:"state" yaml:"state"`

	// Platform records the OS and architecture.
	Platform Platform `json:"platform" yaml:"platform"`

	// Context contains tool-specific metadata.
	Context GraphContext `json:"context" yaml:"context"`

	// Nodes are the actions to perform/performed.
	Nodes []*Node `json:"nodes" yaml:"nodes"`

	// Edges are the dependencies between nodes.
	Edges []Edge `json:"edges,omitempty" yaml:"edges,omitempty"`

	// Phases defines the ordered lifecycle phases (nil for non-phased graphs).
	// When present, the executor uses phase-aware execution with retry and rollback.
	// When nil, the executor falls back to flat node execution.
	Phases []*Phase `json:"phases,omitempty" yaml:"phases,omitempty"`

	// Collisions records source conflicts resolved during tree building (writ-specific).
	Collisions []Collision `json:"collisions,omitempty" yaml:"collisions,omitempty"`

	// Summary contains execution statistics (populated after Run).
	Summary Summary `json:"summary,omitempty" yaml:"summary,omitempty"`

	// Rollback records compensating actions executed during rollback (populated on failure).
	Rollback []RollbackEntry `json:"rollback,omitempty" yaml:"rollback,omitempty"`

	// Checksum is the git-style integrity hash.
	Checksum string `json:"checksum,omitempty" yaml:"checksum,omitempty"`

	// Signature contains the cryptographic signature (optional).
	Signature *Signature `json:"signature,omitempty" yaml:"signature,omitempty"`

	// Catalog is the append-only resource catalog for planning.
	// One per Graph. Not serialized — planning-only state.
	Catalog *ResourceCatalog `json:"-" yaml:"-"`
}

type GraphContext struct {
	// SourceRoot is the source directory (writ: repo path, lore: registry cache).
	SourceRoot string `json:"source_root,omitempty" yaml:"source_root,omitempty"`

	// TargetRoot is the target directory (typically $HOME).
	TargetRoot string `json:"target_root,omitempty" yaml:"target_root,omitempty"`

	// Projects lists the projects included (writ-specific).
	Projects []string `json:"projects,omitempty" yaml:"projects,omitempty"`

	// Packages lists the packages included (lore-specific).
	Packages []string `json:"packages,omitempty" yaml:"packages,omitempty"`

	// Segments contains platform segment values (writ-specific).
	Segments map[string]string `json:"segments,omitempty" yaml:"segments,omitempty"`

	// Layers lists repository layers used (writ-specific).
	Layers []string `json:"layers,omitempty" yaml:"layers,omitempty"`

	// Platform is the target platform string (lore-specific, e.g., "Darwin", "Linux.Debian").
	TargetPlatform string `json:"target_platform,omitempty" yaml:"target_platform,omitempty"`

	// Features enabled for package installation (lore-specific).
	Features []string `json:"features,omitempty" yaml:"features,omitempty"`

	// Settings for package installation (lore-specific).
	Settings map[string]string `json:"settings,omitempty" yaml:"settings,omitempty"`
}

type GraphState string

type HostProvider interface {
	// PackageManager returns the preferred package manager.
	PackageManager() PackageManagerProvider

	// InstalledBy returns the PM that installed the named package (nil if not installed).
	InstalledBy(name string) PackageManagerProvider

	// AllInstalledBy returns all PMs that have the package installed.
	AllInstalledBy(name string) []PackageManagerProvider

	// GetPackageManager returns a specific PM by name (nil if unavailable).
	GetPackageManager(name string) PackageManagerProvider

	// ServiceManager returns the service manager for this platform.
	ServiceManager() ServiceManagerProvider
}

type ImmediateFactory func(cfg BindingConfig) starlark.Value

type MethodParams map[string][]string

type NoResult struct{}

type Node struct {
	// ID is the unique identifier (typically relative target path or package name).
	ID string `json:"id" yaml:"id"`

	// Action to perform. Serialized as the action name string; deserialized
	// as a stubAction. The executor calls Do directly via the Action interface.
	Action Action `json:"-" yaml:"-"`

	// Status of this node: pending, completed, skipped, failed.
	Status NodeStatus `json:"status" yaml:"status"`

	// Timestamp is when this action completed.
	Timestamp string `json:"timestamp,omitempty" yaml:"timestamp,omitempty"`

	// Slots holds input values for this node. Each slot can be:
	// - Immediate: value known at analysis time
	// - Promise: reference to another node's output (creates edge)
	Slots map[string]SlotValue `json:"slots,omitempty" yaml:"slots,omitempty"`

	// Project this node belongs to.
	Project string `json:"project,omitempty" yaml:"project,omitempty"`

	// Layer is the repository layer (base, team, personal).
	Layer string `json:"layer,omitempty" yaml:"layer,omitempty"`

	// Error message if status is failed.
	Error string `json:"error,omitempty" yaml:"error,omitempty"`

	// Retry is the retry policy for this node (nil = no retry).
	Retry *RetryPolicy `json:"retry,omitempty" yaml:"retry,omitempty"`

	// Annotations holds extensible metadata (serialized to receipts).
	Annotations map[string]string `json:"annotations,omitempty" yaml:"annotations,omitempty"`
}

type NodeStatus string

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

type PackageManager interface {
	Name() string
	Installed(name string) bool
	Version(name string) string
	Available(name string) bool
	Search(query string, limit int) []SearchResult
	Install(packages ...string) PlatformResult
	Remove(name string) PlatformResult
	Update() PlatformResult
	AddRepo(url, keyURL, name string) PlatformResult
	NeedsSudo() bool
}

type PackageManagerProvider interface {
	// Name returns the package manager identifier (e.g., "brew", "apt").
	Name() string

	// Installed checks if a package is installed.
	Installed(name string) bool

	// Version returns the installed version of a package.
	Version(name string) string

	// Available checks if a package exists in the repositories.
	Available(name string) bool

	// Install installs one or more packages.
	Install(packages ...string) error

	// Remove removes a package.
	Remove(name string) error

	// Update refreshes the package index.
	Update() error

	// NeedsSudo returns true if operations require privilege elevation.
	NeedsSudo() bool
}

type Phase struct {
	// ID is the unique identifier (e.g., "phase.install").
	ID string `json:"id" yaml:"id"`

	// Name is the phase name (e.g., "install").
	Name string `json:"name" yaml:"name"`

	// Status of this phase: pending, completed, failed, rolled_back, skipped.
	Status PhaseStatus `json:"status" yaml:"status"`

	// Retry governs retry behavior when inner nodes fail.
	Retry *RetryPolicy `json:"retry,omitempty" yaml:"retry,omitempty"`

	// NodeIDs lists the IDs of inner nodes belonging to this phase.
	NodeIDs []string `json:"nodes,omitempty" yaml:"nodes,omitempty"`

	// Compensate is the ID of the compensating action for rollback.
	Compensate string `json:"compensate,omitempty" yaml:"compensate,omitempty"`

	// Attempts records retry history (populated during execution).
	Attempts []Attempt `json:"attempts,omitempty" yaml:"attempts,omitempty"`

	// State holds execution metadata captured during the forward action.
	// The compensating action reads this to know what to undo.
	State map[string]any `json:"state,omitempty" yaml:"state,omitempty"`
}

type PhaseStatus string

type PlannedFactory func(graph *Graph, project string, reg *ActionRegistry) starlark.Value

type Platform struct {
	// Serializable info (used by Graph)
	OS       string `json:"os" yaml:"os"`
	Arch     string `json:"arch" yaml:"arch"`
	Distro   string `json:"distro,omitempty" yaml:"distro,omitempty"`
	Version  string `json:"version,omitempty" yaml:"version,omitempty"`
	Hostname string `json:"hostname,omitempty" yaml:"hostname,omitempty"`

	// Runtime — not serialized
	PackageManager  PackageManager            `json:"-" yaml:"-"`
	PackageManagers map[string]PackageManager `json:"-" yaml:"-"`
	ServiceManager  ServiceManager            `json:"-" yaml:"-"`
}

type PlatformResult struct {
	OK     bool
	Stdout string
	Stderr string
	Code   int
}

type Provider interface {
	Context() Context
	// contains filtered or unexported methods
}

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

type ProviderBinding struct {
	// Name is the provider identifier (e.g., "file", "ui", "host").
	Name string

	// Access defines when this provider's methods are available.
	Access AccessType

	// Lifetime declares the provider's lifecycle semantics for caching and cleanup.
	Lifetime ProviderLifetime

	// ActionRegistrar registers graph actions from actions_gen.go.
	ActionRegistrar ProviderRegistrar

	// PlannedFactory creates the plan sub-namespace from planned_gen.go.
	PlannedFactory PlannedFactory

	// ImmediateFactory creates the immediate receiver from immediate_gen.go.
	ImmediateFactory ImmediateFactory
}

type ProviderLifetime string

type ProviderRegistrar func(*ActionRegistry)

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

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

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

type ReflectedPlanned struct {
	Receiver
	// contains filtered or unexported fields
}

type ReflectedReceiver struct {
	Receiver
	// contains filtered or unexported fields
}

type Resource interface {
	URI() string
	Scheme() string
	Host() string
	Path() string
	// contains filtered or unexported methods
}

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

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

type Result = any

type RetryPolicy struct {
	// MaxAttempts is the maximum number of retries (0 = no retry, fail immediately).
	MaxAttempts int `json:"max_attempts" yaml:"max_attempts"`

	// Backoff is the delay strategy: none, linear, exponential.
	Backoff BackoffStrategy `json:"backoff" yaml:"backoff"`

	// InitialDelay is the delay before the first retry (Go duration string, e.g. "1s").
	InitialDelay string `json:"initial_delay,omitempty" yaml:"initial_delay,omitempty"`

	// MaxDelay caps the delay between retries (Go duration string, e.g. "30s").
	MaxDelay string `json:"max_delay,omitempty" yaml:"max_delay,omitempty"`
}

type RollbackEntry struct {
	// Phase is the phase name that was rolled back.
	Phase string `json:"phase" yaml:"phase"`

	// Compensate is the ID of the compensating action.
	Compensate string `json:"compensate" yaml:"compensate"`

	// Status is "completed" or "failed".
	Status string `json:"status" yaml:"status"`

	// Error is the error message if the compensating action failed.
	Error string `json:"error,omitempty" yaml:"error,omitempty"`
}

type SearchResult struct {
	Name        string
	Version     string
	Description string
}

type ServiceManager interface {
	Exists(name string) bool
	IsRunning(name string) bool
	IsEnabled(name string) bool
	Status(name string) string
	Start(name string) PlatformResult
	Stop(name string) PlatformResult
	Enable(name string) PlatformResult
	Disable(name string) PlatformResult
	NeedsSudo() bool
}

type ServiceManagerProvider interface {
	// Exists checks if a service exists.
	Exists(name string) bool

	// IsRunning returns true if the named service is currently running.
	IsRunning(name string) bool

	// IsEnabled returns true if the named service is enabled to start at boot.
	IsEnabled(name string) bool

	// Start starts a service.
	Start(name string) error

	// Stop stops a service.
	Stop(name string) error

	// Enable enables a service at boot.
	Enable(name string) error

	// Disable disables a service at boot.
	Disable(name string) error
}

type Signature struct {
	// Method is the signing method used (gpg, aws_kms, gcp_kms, azure_kv).
	Method string `json:"method" yaml:"method"`

	// Value is the signature data (base64-encoded).
	Value string `json:"value" yaml:"value"`

	// KeyID identifies the key used for signing.
	// For GPG: fingerprint, for KMS: key ARN/ID/URL.
	KeyID string `json:"key_id" yaml:"key_id"`
}

type SlotValue struct {
	// Immediate is the direct value (any type, known at analysis time).
	Immediate any `json:"immediate,omitempty" yaml:"immediate,omitempty"`

	// NodeRef is the ID of the node that produces this value (promise).
	NodeRef string `json:"node_ref,omitempty" yaml:"node_ref,omitempty"`

	// Slot is which output slot of the referenced node (empty = default output).
	Slot string `json:"slot,omitempty" yaml:"slot,omitempty"`

	// GatherRef is the gather node ID for proxy resolution.
	GatherRef string `json:"gather_ref,omitempty" yaml:"gather_ref,omitempty"`

	// Field is the field name to access on the proxy item.
	Field string `json:"field,omitempty" yaml:"field,omitempty"`
}

type Summary struct {
	TotalFiles int `json:"total_files,omitempty" yaml:"total_files,omitempty"`
	Links      int `json:"links,omitempty" yaml:"links,omitempty"`
	Copies     int `json:"copies,omitempty" yaml:"copies,omitempty"`
	Templates  int `json:"templates,omitempty" yaml:"templates,omitempty"`
	Secrets    int `json:"secrets,omitempty" yaml:"secrets,omitempty"`
	Packages   int `json:"packages,omitempty" yaml:"packages,omitempty"`
	Skipped    int `json:"skipped,omitempty" yaml:"skipped,omitempty"`
	Failed     int `json:"failed,omitempty" yaml:"failed,omitempty"`
}

type Tombstone interface {
	Resource() Resource
	// contains filtered or unexported methods
}

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

type UndoState = any