renderstage

type CoverageError struct {
	// Path is the uncovered major-qualified module path.
	Path string

	// RequiredBy names the input(s) whose module file lists the path.
	RequiredBy []string
}

type Dep struct {
	// Version is the canonical dependency version ("v1.2.3", "v2.0.0-alpha.9").
	Version string

	// Default marks this major as the default for imports of the path that
	// omit a major qualifier.
	Default bool
}

type GlueInputs struct {
	// InstancePath is the instance package's import path: the instance
	// module's qualified path plus the package directory, with an explicit
	// package qualifier when the package name differs from the directory.
	InstancePath string

	// PlatformPath is the platform package's import path, formed the same way.
	PlatformPath string

	// RuntimeName is the executing runtime's identity, entering the build as
	// a CUE string literal.
	RuntimeName string
}

type LocalModFile struct {
	// Replacements maps each replaced major-qualified path to its target: an
	// absolute directory (a relative one is resolved against the input's
	// module root, since cue/load resolves it against the main module's root
	// and the render module's root is elsewhere), or a module path verbatim.
	Replacements map[string]string

	// Deps is every entry the local file lists, versions and default markers
	// as cue/load reads them against the module file (a version omitted in
	// the local file is the module file's). Replacement targets are on
	// Replacements, never here.
	Deps map[string]Dep
}

type ModFile struct {
	// Module is the qualified module path, major suffix included
	// ("testing.opmodel.dev/library-parity@v0").
	Module string

	// Language is the declared language.version ("v0.17.0").
	Language string

	// Deps maps major-qualified dependency paths ("opmodel.dev/core@v2") to
	// their entries. A dependency may carry no version: cue accepts the
	// shape for a path a local replacement serves, and promotion refuses it
	// when no promoted replacement covers the path.
	Deps map[string]Dep
	// contains filtered or unexported fields
}

type Promotion struct {
	// Deps is the promoted dependency list keyed by major-qualified path. It
	// includes the two input modules themselves: cue/load resolves an
	// unqualified import inside a dependency (a module importing its own
	// subpackage, "example.com/mod/identity" from within example.com/mod@v0,
	// the ordinary authoring shape) through the MAIN module's default-major
	// table, which it reads from cue.mod/module.cue only. A replacement in
	// local-module.cue carries no default of its own, so without this entry
	// the input's self-imports fail with "cannot find module providing
	// package". The entry's version is a placeholder ([ReplacedVersion]):
	// the directory replacement serves the module and the version is never
	// resolved; the modfile decoder refuses a null version.
	Deps map[string]Dep

	// Language is the render module's language.version: the maximum of the
	// two inputs' declared versions, floored at MinLanguageVersion.
	Language string

	// Replacements maps each replaced qualified path to its target (the
	// local-module.cue replaceWith): each input module's own path to the
	// absolute directory cue/load serves it from, plus every promoted
	// replacement from the inputs' own local views, an absolute directory
	// or a module path.
	Replacements map[string]string

	// Rows is one row per promoted local replacement, in path order: the
	// developer's redirections the render honours, for the kernel to report
	// as data. The two input directories are the mechanism, not a row.
	Rows []ReplacementRow
}

type ReplacementRow struct {
	Path   string
	Target string

	// By is "platform" or "instance".
	By string
}

type Staged struct {
	// Dir is the render module's root: cue.mod/module.cue,
	// cue.mod/local-module.cue and render.cue live here, and nothing else.
	Dir string

	// Overlay holds every file of an overlay-mode input, keyed under Dir at
	// the directory its local-module.cue replacement names (<Dir>/instance,
	// <Dir>/platform). Build serves them to cue/load through
	// load.Config.Overlay; none of them is written to Dir. Empty when both
	// inputs are on disk.
	Overlay map[string][]byte

	// Skew holds the per-path resolved-versions rows (D18), instance list
	// against platform list.
	Skew []VersionRow

	// Replacements holds one row per local replacement the render module
	// honours (an input's own cue.mod/local-module.cue, promoted), in path
	// order. Nil unless the caller enabled local replacements and an input
	// carried one that promotion kept.
	Replacements []ReplacementRow
}

type VersionRow struct {
	// Path is the major-qualified module path compared.
	Path string

	// ModuleVersion is the version the instance module's cue.mod requires.
	ModuleVersion string

	// PlatformVersion is the version the platform module's tidied list
	// carries. Empty when the platform does not list the path (the instance's
	// own entry is then what the render resolves).
	PlatformVersion string

	// Newer is true when the instance requires a build newer than the
	// platform carries: the D7 skew case the caller's policy decides.
	Newer bool
}