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 = execution.Handoff

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 {
	// Logger optionally overrides the runtime logger (for request-scoped replay).
	Logger             *slog.Logger
	ConsumerVersions   map[string]string
	Allocation         execution.Allocation
	ReadOnlyReplay     bool
	StageExecution     func(jobdb.JobKey, execution.Demand)
	WrapTaskWorker     func(jobworkflow.TaskWorker) jobworkflow.TaskWorker
	CELOptionsProvider template.CELOptionsProvider
	BeforeScope        func(context.Context, string, *template.ResolutionContext) error

	// 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"`
}

type WorkspaceResolutionInput struct {
	Permissions   *permissions.State   `json:"permissions,omitempty"`
	GitProfile    gitprofile.Selection `json:"git_profile,omitzero"`
	Cell          string               `json:"cell"`
	Initial       string               `json:"initial,omitempty"`
	Ref           string               `json:"ref,omitempty"`
	ScopeID       string               `json:"scope_id"`
	ParentScopeID string               `json:"parent_scope_id,omitempty"`
	Resolution    cellref.Context      `json:"resolution"`
}

type WorkspaceResolutionOutput struct {
	Workspace contextual.WorkspaceContext `json:"workspace"`
	Git       contextual.GitBaseContext   `json:"git"`
}