platform

type ComparablePredicates struct {
	// Broader is the implementation FQN of the transformer whose predicate
	// contains the other's: it matches every component Narrower matches.
	Broader string `json:"broader"`

	// Narrower is the implementation FQN of the contained transformer.
	Narrower string `json:"narrower"`

	// Contracts lists the catalog-fulfilled contract FQNs both predicates
	// require, the bucket the pair is undiscriminated within.
	Contracts []string `json:"contracts"`
}

type ContractInventory struct {
	// DefinedBy maps each contract FQN exactly one enabled catalog lists
	// to the registry key (the catalog's module path) of the catalog
	// listing it: the value every diagnostic prints beside the contract. A
	// colliding key (Collisions) is absent.
	DefinedBy map[string]string `json:"definedBy"`

	// RequiredBy maps each defined contract FQN to the implementation FQNs
	// of every enabled transformer whose requiredResources or
	// requiredTraits name it, in the build's order. Required demands only
	// (0010:D32: optional consumption is tolerance, not fulfilment); a
	// defined contract nothing requires maps to an empty list. A colliding
	// key is not defined, so it is absent however many transformers
	// require it.
	RequiredBy map[string][]string `json:"requiredBy"`

	// ProvidedBy maps every provider-fulfilled contract FQN some enabled
	// transformer requires (defined by an enabled catalog or not) to the
	// sorted registry keys (path@major) of the enabled entries whose
	// transformers require it. OverSubscribed is exactly its keys with two
	// or more entries; a key a defined provider contract lacks is
	// Unfulfilled. It is the field a caller prints to name the supplying
	// entries, including when DefinedBy and RequiredBy lack the key (the
	// defining catalog is disabled or absent).
	ProvidedBy map[string][]string `json:"providedBy"`

	// Unfulfilled lists the provider-fulfilled resources and traits an
	// enabled catalog defines and no enabled registry entry provides (no
	// ProvidedBy key). A report the operator surfaces as a non-gating
	// condition (0015:D18), never a refusal. A colliding key is not
	// defined, so it is never listed here.
	Unfulfilled []string `json:"unfulfilled"`

	// OverSubscribed lists the provider-fulfilled resources and traits
	// required by transformers of two or more enabled registry entries
	// (path plus major), whether or not an enabled catalog defines them:
	// the ProvidedBy keys with two or more entries, and what the generation
	// step refuses on (0010:D37). ProvidedBy names the entries.
	OverSubscribed []string `json:"overSubscribed"`

	// Comparable lists every pair of enabled transformers whose match
	// predicates are comparable over at least one shared catalog-fulfilled
	// contract (0015:D5), in the build's comprehension order. The accessor
	// does not sort; a caller that needs a stable order sorts. Only
	// defined contracts are compared, so no row shares a colliding key,
	// even when two transformers require one under equal predicates.
	Comparable []ComparablePredicates `json:"comparable"`

	// Fulfilled is true exactly when Unfulfilled is empty. It is blind to
	// Collisions: it can read true while Collisions is non-empty.
	Fulfilled bool `json:"fulfilled"`

	// Routable is true exactly when OverSubscribed and Collisions are both
	// empty.
	Routable bool `json:"routable"`

	// Discriminated is true exactly when Comparable is empty. It is blind
	// to Collisions: it can read true while Collisions is non-empty.
	Discriminated bool `json:"discriminated"`

	// Collisions lists, ascending, every contract FQN that two or more
	// enabled registry entries' catalogs list in their contract maps. Such
	// a key is in none of DefinedBy, RequiredBy, Unfulfilled or
	// Comparable, and Routable is false while any exists. A disabled entry
	// never counts as a definer. Empty on a platform pinning a core older
	// than [schema.CollisionsSince], which cannot evaluate a colliding
	// platform at all.
	Collisions []string `json:"collisions"`

	// CollidingEntries maps each Collisions key to the ascending registry
	// keys (path@major) of the enabled entries whose catalogs list it.
	CollidingEntries map[string][]string `json:"collidingEntries"`
}

type Platform struct {
	// Metadata is the decoded platform-level metadata cache. Authoritative
	// data lives in Package; Metadata exists for hot-path access (logging,
	// name lookups). May be nil when the metadata could not be decoded.
	Metadata *PlatformMetadata `json:"metadata"`

	// Package is the loaded CUE value for the platform artifact, the
	// evaluated form of the package Source points at.
	Package cue.Value `json:"-"`

	// Source is the staged source tree the platform package was loaded from,
	// so a follow-on build can import the platform as a package. It is
	// stamped by Kernel.AcquirePlatformFromDir (on-disk mode, the loaded
	// directory) and is nil for platforms constructed from a bare value
	// (NewPlatformFromValue). Source is the render input: Kernel.Render
	// imports the platform package from it, so a platform without Source
	// cannot be rendered against. No other kernel operation reads it.
	Source *Source `json:"-"`
}

type PlatformMetadata = schema.PlatformMetadata

type Source = module.Source