render

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

type Inputs struct {
	// Spec is the observed composite resource's user spec. The engine projects
	// out Crossplane-reserved keys before unifying it against the module #Spec.
	Spec map[string]any `json:"spec,omitempty"`

	// Metadata is the observed composite resource's identifying metadata.
	Metadata Metadata `json:"metadata"`

	// Environment is the merged EnvironmentConfig data from the pipeline context,
	// empty when no environment was supplied.
	Environment map[string]any `json:"environment,omitempty"`

	// RequiredResources holds the cluster objects Crossplane fetched for the
	// requirements this module emitted on a previous pass, keyed by the author's
	// requirement name. An empty list means "requested but none found". omitempty
	// keeps it off out.input before any requirement is delivered.
	RequiredResources map[string][]map[string]any `json:"requiredResources,omitempty"`

	// ObservedResources holds the composed Kubernetes objects Crossplane supplied
	// on the current request, keyed by the author's stable resource name. The
	// engine exposes it only when the loaded module declares observedResources as
	// a regular field under out.input; optional or absent declarations are omitted.
	ObservedResources map[string]map[string]any `json:"observedResources,omitempty"`
}

type Loaded struct {
	// Dir is the module root directory (containing cue.mod) to load.
	Dir string

	// Registry resolves the module's transitive CUE dependencies during load.
	// It is nil for self-contained modules served from disk (LocalLoader), in
	// which case the engine loads without a registry and dep-free modules render
	// identically.
	Registry modconfig.Registry

	// Cleanup releases any resources the loader allocated. It is always non-nil
	// and safe to call exactly once; a persistent cache returns a no-op.
	Cleanup func()
}

type LocalLoader struct {
	// Dir is the module root directory (containing cue.mod) to serve.
	Dir string
	// contains filtered or unexported fields
}

type Metadata struct {
	// Name is the composite resource's name.
	Name string `json:"name,omitempty"`

	// Namespace is the composite resource's namespace.
	Namespace string `json:"namespace,omitempty"`
}

type ModuleLoader interface {
	// Load fetches the module identified by ref ("path@version") and returns a
	// [Loaded] describing the local directory, an optional dependency registry,
	// and a cleanup func the caller must invoke when done.
	Load(ctx context.Context, ref string) (Loaded, error)
}

type OCIConfig struct {
	// Env provides environment variables (CUE_REGISTRY, CUE_CACHE_DIR, ...) used
	// to build the registry clients. When nil, the process environment
	// (os.Environ) is used. Injecting Env keeps resolution explicit and avoids
	// relying on process-global state under parallel tests.
	Env []string

	// CacheDir is the writable directory used for both CUE's module cache and the
	// loader's digest-keyed extraction cache. When set it overrides CUE_CACHE_DIR
	// in Env, which makes caching work for a nonroot or read-only-root container.
	// When empty, CUE_CACHE_DIR (or the OS user cache) is used.
	CacheDir string

	// Expect maps a module ref ("path@version") to the manifest digest the loader
	// must observe after fetch. A mismatch fails the load. Refs absent from the
	// map are not digest-checked. This is the runtime half of the schema<->runtime
	// digest lock-step: CUE references modules by semver, not digest, so the
	// expected digest is verified after fetch rather than referenced directly.
	//
	// Only the root module ref passed to Load is verified. Transitive dependency
	// refs in this map are ignored: deps are resolved immutably by version through
	// CUE's module cache, so a per-dep digest lock is out of scope here.
	Expect map[string]string
}

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

type Requirement struct {
	APIVersion  string            `json:"apiVersion"`
	Kind        string            `json:"kind"`
	MatchName   string            `json:"matchName,omitempty"`
	MatchLabels map[string]string `json:"matchLabels,omitempty"`
	Namespace   string            `json:"namespace,omitempty"`
}

type Resource struct {
	// Object is the rendered Kubernetes object as an unstructured map.
	Object map[string]any

	// Ready is the readiness the module assigned. An absent module hint maps to
	// [resource.ReadyUnspecified].
	Ready resource.Ready
}

type Result struct {
	// Resources holds the composed resources keyed by the author's map key
	// verbatim (the Crossplane composed-resource name).
	Resources map[string]Resource

	// Status is the status the module returned, or nil when it returned none.
	Status map[string]any

	// Requirements holds the selectors the module emitted under out.requirements,
	// keyed by requirement name. nil when the module declares none.
	Requirements map[string]Requirement
}