compiler

type CELVariables struct {
	Outputs map[string]interface{}            `json:"Outputs"`
	State   *StateInfo                        `json:"State"`
	States  map[string]map[string]interface{} `json:"States"`
	Inputs  map[string]interface{}            `json:"ContainerInputs"`
	Context *RecipeContext                    `json:"Context"`
	Steps   map[string]interface{}            `json:"Steps"` // Access to step outputs within current state
}

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

type EnvironmentInfo struct {
	Name   string `json:"name"`
	Region string `json:"region"`
}

type ExecutionHandoff struct {
	Kind       string               `json:"kind"`
	JobKey     jobdb.JobKey         `json:"job"`
	Demand     execution.Demand     `json:"demand"`
	Allocation execution.Allocation `json:"allocation"`
	Mismatches []execution.Mismatch `json:"mismatches,omitempty"`
	Published  bool                 `json:"published"`
}

type ExecutionInfo struct {
	StartedAt time.Time     `json:"started_at"`
	Timeout   time.Duration `json:"timeout"`
}

type ExecutionMode string

type ExecutionOptions struct {
	Mode       ExecutionMode
	Validation ValidationOptions
	// Optional CEL options provider to inject extra functions/types.
	CELOptionsProvider  template.CELOptionsProvider
	StateObserver       StateObserver
	DiagnosticsObserver template.DiagnosticsObserver
	// ResolvedSelectors carries internal selector pins for the current recipe run.
	ResolvedSelectors map[string]string
	// ResolvedGitRefs carries internal repo/ref pins for the current recipe run.
	ResolvedGitRefs map[string]string
}

type InlineResolutionOptions struct {
	ProjectID  string
	RootFile   string
	WorkingDir string
	Resolver   RecipeSourceResolver
	RootSource *RecipeSourceResolution
}

type InlineResolutionResult struct {
	Recipe recipe.Recipe
}

type NoOpStateObserver struct{}

type NormalizedOpInput struct {
	Data               map[string]interface{}
	StoredArtifactKeys []jobdb.ArtifactKey
}

type RecipeContext struct {
	Recipe      RecipeInfo      `json:"recipe"`
	Environment EnvironmentInfo `json:"environment"`
	Execution   ExecutionInfo   `json:"execution"`
}

type RecipeExecutor interface {
	ExecuteRecipe(ctx workflow.Context, r recipe.Recipe, rawRecipeInputs map[string]interface{}, execCtx contextual.JobContext, commitContext contextual.GitCommitContext, opts ...ExecutionOptions) (map[string]interface{}, []jobdb.Artifact, error)
	ExecuteNode(ctx workflow.Context, parentResCtx *template.ResolutionContext, n *recipe.Node) error
	ExecuteStateMachine(ctx workflow.Context, parentContext *template.ResolutionContext, metadata recipe.NodeMetadata, outputTemplate map[string]interface{}, stateMap *recipe.StateMap, opts ...ExecutionOptions) error
	ExecuteOp(ctx workflow.Context, parentResolutionContext *template.ResolutionContext, metadata recipe.NodeMetadata, op string) error
	ExecuteChildGroup(ctx workflow.Context, parent *template.ResolutionContext, metadata recipe.NodeMetadata, group recipe.ChildGroupData) error
	ExecuteSequence(ctx workflow.Context, rCtx *template.ResolutionContext, metadata recipe.NodeMetadata, outputTemplate map[string]interface{}, sequence []recipe.Node) error
}

type RecipeInfo struct {
	Name        string `json:"name"`
	Version     string `json:"version"`
	ExecutionID string `json:"execution_id"`
}

type RecipeJobWorkerOptions struct {
	Allocation         execution.Allocation
	ReadOnlyReplay     bool
	OnExecutionHandoff func(ExecutionHandoff)
	StageExecution     func(jobdb.JobKey, execution.Demand)
	WrapTaskWorker     func(jobworkflow.TaskWorker) jobworkflow.TaskWorker
	CELOptionsProvider template.CELOptionsProvider

	// Executor overrides recipe execution for instrumentation. When nil, DefaultRecipeExecutor is used.
	Executor RecipeExecutor
	// ExecutorFactory overrides Executor when provided, allowing per-run executors.
	ExecutorFactory func() RecipeExecutor

	// RootSourceResolver resolves non-embedded root recipe selectors at execution time.
	RootSourceResolver RecipeSourceResolver

	// OnRecipeLoaded is called after the recipe artifact has been loaded and parsed.
	OnRecipeLoaded func(recipeName string)
	// OnRecipeSourceResolved is called after the root recipe source has been resolved.
	OnRecipeSourceResolved func(RecipeSourceResolution)
}

type RecipeRefResolver interface {
	ResolveRecipeRef(ctx context.Context, projectID string, selector string) (RecipeSourceResolution, error)
	LoadRecipeRef(ctx context.Context, projectID string, selector string) (*recipe.Recipe, error)
}

type RecipeRefYAMLLoader interface {
	LoadRecipeRefYAML(ctx context.Context, projectID string, selector string) ([]byte, error)
}

type RecipeSourceKind string

type RecipeSourceResolution struct {
	SourceKind        RecipeSourceKind `json:"source_kind"`
	SubmittedSelector string           `json:"submitted_selector"`
	ResolvedSelector  string           `json:"resolved_selector,omitempty"`
	ResolvedCommit    string           `json:"resolved_commit,omitempty"`
	ArtifactName      string           `json:"artifact_name,omitempty"`
	WasAlreadyPinned  bool             `json:"was_already_pinned"`
}

type RecipeSourceResolver interface {
	Resolve(ctx context.Context, projectID string, selector string) (RecipeSourceResolution, error)
	Load(ctx context.Context, projectID string, resolution RecipeSourceResolution) (recipe.Recipe, error)
}

type RecipeSourceResolverOptions struct {
	// GitRepository is retained for API compatibility. Git selectors are
	// resolved through SelectorCache so extension and recipe sources share one
	// materialization path.
	GitRepository     gitpkg.Repository
	SelectorCache     *selectorcache.Cache
	RecipeRefResolver RecipeRefResolver
}

type RecipeSourceYAMLLoader interface {
	LoadYAML(ctx context.Context, projectID string, resolution RecipeSourceResolution) ([]byte, error)
}

type ResolvedRecipeSource struct {
	RecipeSourceResolution
	RecipeYAML string `json:"recipe_yaml,omitempty"`
}

type ScopedContext struct {
	// Parent scope (nil for root)
	Parent *ScopedContext

	// Local step outputs for this scope only
	LocalStepOutputs map[string]interface{}

	// Reference to the global state context
	StateContext *StateContext

	// Scope identifier for debugging
	ScopeID string
}

type StateContext struct {
	CurrentState  string                            `json:"current_state"`
	Inputs        map[string]interface{}            `json:"inputs"`
	StateOutputs  map[string]map[string]interface{} `json:"state_outputs"`
	Attempts      map[string]int                    `json:"attempts"`
	StateInfo     map[string]*StateInfo             `json:"state_info"`
	RecipeContext *RecipeContext                    `json:"recipe_context,omitempty"`
	StepOutputs   map[string]interface{}            `json:"step_outputs"` // Track step outputs within current state
}

type StateInfo struct {
	Name      string    `json:"name"`
	Attempts  int       `json:"attempts"`
	EnteredAt time.Time `json:"entered_at"`
}

type StateObserver interface {
	StateEntered(stateName string)
	StateExited(stateName string)
	TransitionEvalauted(expression string, result bool, nextStateIfExpressionTrue string)
}

type StepResult struct {
	Outputs map[string]interface{}
}

type TransitionSelectionObserver interface {
	TransitionSelected(fromState string, toState string, payload map[string]interface{})
}

type ValidationMode string

type ValidationOptions struct {
	Mode       ValidationMode
	CollectAll bool
}

type WithinRecipeResolutionResult struct {
	ResolvedSelectors map[string]string `json:"resolved_selectors,omitempty"`
	ResolvedGitRefs   map[string]string `json:"resolved_git_refs,omitempty"`
}