renderer

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

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

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

type ColdIncrementalRenderConfig struct {
	Config             *config.Config
	Engine             templating.Engine
	StoreProvider      stores.StoreProvider
	Mode               rendercontext.RenderMode
	TemplateContext    map[string]any
	ResourceErrors     *rendercontext.ResourceErrorCollector
	NamespaceScopes    func(string) *rendercontext.NamespaceScope
	Logger             *slog.Logger
	TypedResourceTypes map[string]reflect.Type
	// Analysis, when set, must come from AnalyzeColdIncrementalRenders over
	// this Config and Engine; nil analyzes them for this render alone.
	Analysis *ColdIncrementalRenderAnalysis
}

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

type IncrementalCacheBuildObserver interface {
	IncrementalCacheBuildStarted(context.Context, IncrementalCacheBuildIdentity)
	IncrementalCacheBuildCompleted(IncrementalCacheBuildIdentity, error)
}

type RenderInputTransaction interface {
	// HasCandidates reports whether this render is the first to accept some
	// external content, which is what the commit gate keys on.
	HasCandidates() bool
	Commit(context.Context) error
	Abort()
}

type RenderResult struct {
	// HTTPObservations records fresh accepted reads independently of transaction wrappers.
	HTTPObservations []purehttpstore.ObservationToken

	// CycleSnapshot binds the output and every effect from this render.
	CycleSnapshot *rendercycle.Snapshot

	// OutputSnapshot binds the exact config, plan, and auxiliary artifacts.
	OutputSnapshot *renderoutput.Snapshot

	// HAProxyConfig is the rendered HAProxy configuration.
	HAProxyConfig string

	// AuxiliaryFiles contains all rendered auxiliary files (maps, certs, general).
	// Production renders leave it nil and use AuxiliaryFileSnapshot.
	AuxiliaryFiles *dataplane.AuxiliaryFiles

	// AuxiliaryFileSnapshot is the authenticated immutable production representation.
	AuxiliaryFileSnapshot *renderartifact.Snapshot

	// ContentChecksum covers HAProxyConfig and every auxiliary-file identifier and byte.
	ContentChecksum string

	// Plan is the structure the templates declared about this render: the
	// ordered sections of the config, the backend records behind them, the map
	// entries and the file set.
	Plan *renderplan.Plan

	// PlanID identifies the plan — the digest downstream consumers compare on.
	PlanID string

	// StatusPatches is the detached compatibility representation.
	// Production renders leave it nil and use StatusPatchSnapshot.
	StatusPatches []templating.StatusPatch

	// StatusPatchSnapshot carries the same patches without materializing payload maps.
	StatusPatchSnapshot *templating.StatusPatchSnapshot

	// Events contains Kubernetes Events templates asked to emit via recordEvent()
	// (e.g. a RouteConflict Warning on an Ingress whose route lost to an older
	// one). Resource-agnostic — each carries its own apiVersion/kind/namespace/name.
	// Production renders leave it nil and use EventSnapshot.
	Events []templating.RenderedEvent

	// EventSnapshot is the authenticated immutable production representation.
	EventSnapshot *templating.RenderedEventSnapshot

	// RenderedResources contains full Kubernetes resources the templates declared
	// the controller should own and reconcile (e.g. an auxiliary Service or other
	// object a template emits alongside the HAProxy config). The applier compares
	// each against the last-applied checksum and skips unchanged entries to avoid
	// hammering the API server.
	// Production renders leave it nil and use RenderedResourceSnapshot.
	RenderedResources []templating.RenderedResource

	// RenderedResourceSnapshot is the authenticated immutable production representation.
	RenderedResourceSnapshot *templating.RenderedResourceSnapshot

	// DurationMs is the total render duration in milliseconds.
	DurationMs int64

	// CacheState is "warm" when this render had a graph to build on, "cold" when
	// it re-evaluated everything, and "replay" when it reused the previous output.
	CacheState string

	// CacheBuildMs is what the most recent completed cache build cost, or 0 while
	// none has completed.
	CacheBuildMs int64

	// RootsReused counts the auxiliary roots that handed back their previous
	// output instead of executing, because they observed nothing new.
	RootsReused int

	// IncludeStats holds per-snippet render counts/timing for the main template.
	// Populated only when the engine was built with profiling enabled (nil in
	// production); consumed by the browser playground's render-trace view.
	IncludeStats []templating.IncludeStats

	// AuxFileCount is the total number of auxiliary files.
	AuxFileCount int

	// InputTransaction owns render-local inputs until the full pipeline decides their fate.
	InputTransaction RenderInputTransaction
	// contains filtered or unexported fields
}

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

type RenderServiceConfig struct {
	// Engine is the template engine to use for rendering.
	Engine templating.Engine

	// Config is the controller configuration.
	Config *config.Config

	// Logger is the structured logger for logging.
	Logger *slog.Logger

	// Capabilities defines HAProxy version capabilities.
	Capabilities dataplane.Capabilities

	// HAProxyPodStore is the store containing HAProxy pods (optional).
	HAProxyPodStore stores.Store

	// HTTPStoreComponent is the HTTP store for dynamic content (optional).
	HTTPStoreComponent *httpstore.Component

	// IncrementalCacheBuildObserver receives optional cold-cache lifecycle notifications.
	IncrementalCacheBuildObserver IncrementalCacheBuildObserver

	// AdmissionSlotWaitObserver, if set, receives how long each admission
	// render waited for its slot, whether or not it got one.
	AdmissionSlotWaitObserver func(time.Duration)

	// CurrentAuxFilesProvider returns the default auxiliary baseline. The
	// Coordinator overrides it with a leader-term snapshot for reconciliation.
	CurrentAuxFilesProvider func() map[string]string

	// ColdRendersRunToCompletion lets a reconcile render that starts without
	// a committed graph run past the render timeout until its context ends,
	// one at a time. Set it only when every reconcile caller's context ends on
	// shutdown or leadership loss; a caller without one, such as the
	// playground, relies on the timeout to stop a template that never returns.
	ColdRendersRunToCompletion bool

	// TypedResourceTypes carries the generated Go types produced
	// by pkg/controller/typebootstrap at iteration start. The
	// renderer emits one *[]*<generated-struct> top-level context
	// entry per type at render time, matching the typed-global
	// declarations the engine constructor received.
	//
	// Optional. nil or empty means typed-resource access isn't
	// available and templates fall back to the untyped
	// resources["<name>"] path.
	TypedResourceTypes map[string]reflect.Type
}

type TemplateSourceMap struct {
	Raw   string
	Spans []templating.SourceSpan
}