engine

type BackupOp struct{}

type BuildOptions struct {
	// DryRun prevents the builder from making any filesystem queries
	// that have side effects.
	DryRun bool

	// Features lists enabled features (e.g., "rootless", "compose").
	Features []string

	// Data holds tool context: platform info, environment, segments.
	Data map[string]any
}

type Conflict struct {
	Node         *Node
	Type         ConflictType
	ExistingPath string // For symlinks, where it points
	Message      string
}

type ConflictResolution int

type ConflictType int

type Context struct {
	context.Context

	// DryRun prevents filesystem modifications when true.
	DryRun bool

	// Logger receives operation output messages.
	Logger io.Writer

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

type CopyOp struct{}

type DecryptOp struct{}

type DelegateOp struct{}

type Edge struct {
	From     string // Source node ID
	To       string // Target node ID
	Relation string // "depends_on", "delegates", "orders"
}

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

type ExpandOp struct{}

type Graph struct {
	Nodes []*Node
	Edges []Edge
}

type GraphBuilder interface {
	BuildGraph(ctx context.Context, manifestPath string, opts BuildOptions) (*Graph, error)
}

type LinkOp struct{}

type Node struct {
	// ID uniquely identifies this node (e.g., relative target path for writ,
	// package name for lore).
	ID string

	// Operations is the pipeline of operations to execute on this node.
	// Examples: ["link"], ["decrypt", "expand", "copy"], ["install"].
	Operations []string

	// Source is the source path (for file operations).
	Source string

	// Target is the target path (for file operations).
	Target string

	// Project is the grouping key (writ: project name, lore: package name).
	Project string

	// Mode is the target file permissions (0 means use default 0644).
	Mode os.FileMode

	// DelegateTo names the tool to delegate to (for delegate operations).
	DelegateTo string

	// Metadata holds tool-specific extensions.
	Metadata map[string]string
}

type Operation interface {
	// Execute performs the operation on the given node with pipeline state.
	// Transforms modify state.Content in place. Writers consume state.Content
	// and produce filesystem output. Direct operations ignore state.Content.
	Execute(ctx *Context, node *Node, state *PipelineState) error

	// Name returns the operation identifier (e.g., "link", "decrypt").
	Name() string
}

type Options struct {
	// DryRun prevents filesystem modifications.
	DryRun bool

	// Logger receives operation output.
	Logger io.Writer

	// Data holds tool-provided context (template vars, SOPS config, etc.).
	Data map[string]any

	// ConflictResolution specifies how to handle conflicts detected during preflight.
	ConflictResolution ConflictResolution

	// BackupSuffix is appended to backup filenames (default: ".writ-backup").
	BackupSuffix string
}

type PipelineState struct {
	// Content is the current file content. Transforms modify this in place;
	// writers consume it to produce output files.
	Content []byte

	// SourceChecksum is computed from the original source file content
	// before any transforms are applied. Format: "sha256:<hex>".
	SourceChecksum string

	// TargetChecksum is set by writer operations after writing content
	// to the target path. Format: "sha256:<hex>".
	TargetChecksum string

	// Metadata holds per-node extensible state that operations can read/write.
	Metadata map[string]string
}

type PreflightResult struct {
	Conflicts   []Conflict
	AlreadyDone []Conflict // Symlinks that already point correctly
	Ready       []*Node    // Nodes ready to deploy (no conflict)
}

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

type RemoveOp struct{}

type Result struct {
	NodeID         string
	Status         Status
	Error          error
	Message        string
	SourceChecksum string
	TargetChecksum string
}

type Status int

type UnlinkOp struct{}