compiler

type CapabilityValidator struct{}

type CheckedFunctionProvider interface {
	CheckedFunctionContract() ir.FunctionContract
	CheckedFunctionImplementation() any
	CheckedFunctionDescriptor() any
}

type CompilationError struct {
	Type        string // "type_error", "dependency_error", "capability_error"
	Component   string // "verb", "function", "expression"
	Location    string // verb name, function name, etc.
	Message     string
	Suggestions []string
}

type CompilationResult struct {
	Success      bool
	Errors       []CompilationError
	Warnings     []CompilationWarning
	CompiledUnit *CompiledUnit
}

type CompilationWarning struct {
	Type     string
	Location string
	Message  string
}

type CompileOptions struct {
	ExecutionPolicy effectusv1.ExecutionPolicy
	Limits          ir.Limits
	// InspectSource receives each normalized AST exactly once before lowering.
	// The callback must treat the file as immutable and must not retain it.
	InspectSource func(path string, file *ast.File)
}

type CompiledFunction struct {
	Name               string
	Implementation     interface{}
	ResolverDescriptor any
	TypeSignature      *TypeSignature
	Dependencies       []string
}

type CompiledSpec struct {
	List *list.Spec
	Flow *flow.Spec
	Name string
}

type CompiledUnit struct {
	VerbSpecs              map[string]*CompiledVerbSpec
	Functions              map[string]*CompiledFunction
	TypeSystem             *TypeSystem
	ExecutionPlan          *ExecutionPlan
	CheckedIR              *ir.Checked
	IREnvironment          ir.Environment
	InitialData            map[string]interface{}
	Dependencies           []string // External dependencies required
	Capabilities           []string // Required capabilities
	ExtensionSnapshot      *loader.ExtensionSnapshot
	ExecutionOwnedSnapshot bool // retired after recovery acquires its execution handle
}

type CompiledVerbSpec struct {
	Spec               *verb.Spec
	ExecutorType       ExecutorType
	ExecutorConfig     ExecutorConfig
	ExecutorDescriptor *loader.ExecutorDescriptor
	Dependencies       []string // Other verbs this depends on
	TypeSignature      *TypeSignature
	ValidationRules    []ValidationRule
}

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

type DependencyOptimizer struct{}

type DependencyValidator struct{}

type DescriptorExecutorConfig struct {
	Descriptor loader.ExecutorDescriptor
}

type ErrorPolicy string

type ErrorReporter struct{}

type ExecutionPhase struct {
	Name        string
	Verbs       []string
	Parallel    bool
	Timeout     string
	ErrorPolicy ErrorPolicy
}

type ExecutionPlan struct {
	Phases       []ExecutionPhase
	Dependencies map[string][]string // verb -> dependencies
	Capabilities map[string][]string // verb -> required capabilities
	Executors    map[string]ExecutorConfig
}

type ExecutionPlanOptimizer struct{}

type ExecutorConfig interface {
	GetType() ExecutorType
	Validate() error
}

type ExecutorType string

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

type FunctionDefinition struct {
	Name       string
	InputTypes []string
	OutputType string
	Pure       bool // Whether function has side effects
}

type GRPCExecutorConfig struct {
	Address     string            `json:"address"`
	Method      string            `json:"method"` // Fully-qualified method, e.g. /package.Service/Call
	Timeout     string            `json:"timeout"`
	Metadata    map[string]string `json:"metadata"`
	UseTLS      bool              `json:"useTLS"`
	Insecure    bool              `json:"insecure,omitempty"`
	ServerName  string            `json:"serverName,omitempty"`
	RetrySafe   bool              `json:"retrySafe,omitempty"`
	RetryPolicy *RetryPolicy      `json:"retryPolicy,omitempty"`
}

type HTTPExecutorConfig struct {
	URL                 string            `json:"url"`
	Method              string            `json:"method"`
	Headers             map[string]string `json:"headers"`
	Timeout             string            `json:"timeout"`
	AllowPrivateNetwork bool              `json:"allowPrivateNetwork,omitempty"`
	RetryPolicy         *RetryPolicy      `json:"retryPolicy,omitempty"`
}

type LocalExecutorConfig struct {
	Implementation loader.VerbExecutor
}

type MessageExecutorConfig struct {
	Publisher           string            `json:"publisher,omitempty"` // "kafka" or "http"
	Brokers             []string          `json:"brokers,omitempty"`
	URL                 string            `json:"url,omitempty"`
	Headers             map[string]string `json:"headers,omitempty"`
	Topic               string            `json:"topic"`
	Queue               string            `json:"queue"`
	Exchange            string            `json:"exchange"`
	RoutingKey          string            `json:"routingKey"`
	Timeout             string            `json:"timeout"`
	AllowPrivateNetwork bool              `json:"allowPrivateNetwork,omitempty"`
	RetryPolicy         *RetryPolicy      `json:"retryPolicy,omitempty"`
}

type MockExecutorConfig struct{}

type Optimizer interface {
	Optimize(plan *ExecutionPlan) *ExecutionPlan
}

type RetryPolicy struct {
	MaxRetries      int      `json:"maxRetries"`
	InitialDelay    string   `json:"initialDelay"`
	MaxDelay        string   `json:"maxDelay"`
	BackoffFactor   float64  `json:"backoffFactor"`
	RetryableErrors []string `json:"retryableErrors"`
}

type SecurityValidator struct{}

type Source struct {
	Path    string
	Content []byte
	Data    []byte // Deprecated: use Content.
}

type TypeConstraint struct {
	Type        string // "range", "enum", "pattern", "dependency"
	Parameter   string
	Values      []interface{}
	Description string
}

type TypeDefinition struct {
	Name        string                 `json:"name"`
	Type        string                 `json:"type"` // "primitive", "object", "array", "union"
	Properties  map[string]interface{} `json:"properties,omitempty"`
	ElementType *TypeDefinition        `json:"elementType,omitempty"`
	UnionTypes  []*TypeDefinition      `json:"unionTypes,omitempty"`
	Constraints []TypeConstraint       `json:"constraints,omitempty"`
}

type TypeSignature struct {
	InputTypes  map[string]string // arg name -> type
	OutputType  string
	Constraints []TypeConstraint
}

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

type TypeValidator struct{}

type ValidationRule struct {
	Type         string // "input", "output", "capability", "dependency"
	Expression   string
	ErrorMessage string
}

type Validator interface {
	Validate(typeSystem *TypeSystem, verbs map[string]*CompiledVerbSpec) ([]CompilationError, []CompilationWarning)
}