parser

type ActionBlock struct {
	Type   string   `hcl:"type,label"`
	Name   string   `hcl:"name,label"`
	Remain hcl.Body `hcl:",remain"`
}

type ComponentDefBlock struct {
	Name        string           `hcl:"name,label"`
	Description string           `hcl:"description,optional"`
	Tags        []string         `hcl:"tags,optional"`
	Variables   []*VariableBlock `hcl:"variable,block"`
	Actions     []*ActionBlock   `hcl:"action,block"`
	Outputs     []*OutputBlock   `hcl:"output,block"`
}

type ComponentFile struct {
	Component *ComponentDefBlock `hcl:"component,block"`
}

type ComponentRef struct {
	Type   string   `hcl:"type,label"`
	Name   string   `hcl:"name,label"`
	Source string   `hcl:"source,attr"`
	Inputs hcl.Body `hcl:",remain"`
}

type Instance struct {
	Key   cty.Value
	Value cty.Value
}

type Option func(*loadConfig)

type OutputBlock struct {
	Name  string         `hcl:"name,label"`
	Value hcl.Expression `hcl:"value"`
}

type ParsedComponent struct {
	Ref *ComponentRef
	Def *ComponentDefBlock
	// Instance is set when the ref uses count / for_each; nil for a
	// plain single component. Its count.* / each.* namespace is in
	// scope for the ref's inputs.
	Instance *Instance
}

type ParsedScenario struct {
	Scenario   *ScenarioBlock
	Components map[string]*ParsedComponent // keyed by "type.name"
	Variables  map[string]cty.Value

	// RequiredProviders maps a provider name to its declared source,
	// e.g. "postgres" → {Source: "builtin/postgres"}. Populated from
	// the scenario's required_providers block. Empty when absent.
	RequiredProviders map[string]RequiredProviderSpec

	// ProviderConfigs maps a provider name to the evaluated attribute
	// values from its `provider "<name>" {}` block. These are passed
	// to provider.Registry.Configure. Providers without a config
	// block receive an empty map rather than being absent, matching
	// the Configure contract that lets providers start up with
	// default or zero configuration.
	ProviderConfigs map[string]map[string]cty.Value

	// ScenarioDir is the absolute directory containing the scenario
	// file. The engine uses it to resolve `file` attributes on
	// action bodies to absolute paths before dispatching to
	// providers — the same convention as component source paths and
	// exec: provider sources, extended to any action that reads a
	// file.
	ScenarioDir string

	// Sensitive names the scenario variables declared
	// `sensitive = true`. Run records keep a hash of each, not its
	// value.
	Sensitive map[string]bool

	// Seed drives every random function in the run: --seed, else the
	// scenario's seed attribute, else a fresh random one. The run
	// record keeps it so a run can be repeated.
	Seed uint64
}

type ProviderConfigBlock struct {
	Name   string   `hcl:"name,label"`
	Remain hcl.Body `hcl:",remain"`
}

type RequiredProviderSpec struct {
	Source string
}

type RequiredProvidersBlock struct {
	Body hcl.Body `hcl:",remain"`
}

type ScenarioBlock struct {
	Name              string                  `hcl:"name,label"`
	Description       string                  `hcl:"description,optional"`
	Tags              []string                `hcl:"tags,optional"`
	Seed              *uint64                 `hcl:"seed,optional"`
	RequiredProviders *RequiredProvidersBlock `hcl:"required_providers,block"`
	Providers         []*ProviderConfigBlock  `hcl:"provider,block"`
	Variables         []*VariableBlock        `hcl:"variable,block"`
	Components        []*ComponentRef         `hcl:"component,block"`
	Actions           []*ActionBlock          `hcl:"action,block"`
	Outputs           []*OutputBlock          `hcl:"output,block"`
}

type ScenarioFile struct {
	Scenarios []*ScenarioBlock `hcl:"scenario,block"`
}

type VariableBlock struct {
	Name string   `hcl:"name,label"`
	Body hcl.Body `hcl:",remain"`
}