Resolve one node over an Input, its credentials as stand-ins and its settings (issue 1362). Ported from mesh-control 6c2a8d62 planFor. Nothing is made: a pair credential is how it stands (held, to make, only a person's to give, refused), never its value; keepRecorded is left to the caller, who puts the kept manifest in the Catalogue. The bus credential nobody issued and a given own secret under an old key are refused where the controller refuses them, in the rendering (issue 1364).

go/compose/input.go

@@ -50,6 +50,11 @@ type Input struct {
 	CarriedPeers []CarriedPeer
 	// Joining is the nodes that hold a live enrolment token (inv.NodesWithALiveToken).
 	Joining []string
+
+	// Credentials is how each pair credential a node takes from elsewhere stands, never its value (what inv.SecretFor,
+	// SharedSecretFor and GivenPairSecret would answer): held, to be made by the next send, only a person's to give, or
+	// refused. A need with no entry here is one the next send would make.
+	Credentials []Credential
 }
 
 // Node is one node of the mesh and what the composition reads about it.
@@ -76,6 +81,9 @@ type Node struct {
 	Settings map[string][]catalogue.Layer
 	// Ports is the machine port each module's software port was given on it (inv.PortsFor), by module then port.
 	Ports map[string]map[int]int
+	// SealingKey is the public key its secrets are sealed to (inv.SealingKeyOf); empty when it has none. A public key, so
+	// nothing secret.
+	SealingKey string
 }
 
 // Place is where a node is, as its placement says (inv.Overlay).
@@ -138,6 +146,11 @@ type Licence struct {
 	Name    string
 	Serves  map[string]any
 	Holders []Holder
+	// Keys is, by holder, the licence's key sealed to that holder's machine (held.KeyFor), empty where the mesh holds none:
+	// the plaintext was discarded when it was supplied. Optional; the composition needs no value of it.
+	Keys map[Holder]string
+	// Manager is the holder of a refreshable-grant licence that manages it (held.ManagerOf); the zero Holder when none.
+	Manager Holder
 }
 
 // Holder is a module on a node that uses a licence.
@@ -165,3 +178,36 @@ func (in Input) sorted() []Node {
 	sort.Slice(out, func(i, j int) bool { return out[i].Name < out[j].Name })
 	return out
 }
+
+// CredentialState is how one pair credential stands.
+type CredentialState string
+
+const (
+	// CredentialHeld is a credential held for both ends as they stand now. Sealed, when given, is the consumer's copy; a held
+	// credential with no value is composed with a stand-in, named foreseen.
+	CredentialHeld CredentialState = "held"
+	// CredentialWouldMake is a credential none is held for: the next send makes it, and the composition uses a stand-in,
+	// named foreseen. It is also what a need with no entry is.
+	CredentialWouldMake CredentialState = "would-make"
+	// CredentialNotGiven is a credential only a person gives (novox/hq ADR 0337 clause 4) that nobody has given, or that was given
+	// under a key one end no longer has: the consumer still resolves, without it. Why is the controller's words for it.
+	CredentialNotGiven CredentialState = "not-given"
+	// CredentialRefused is a credential the send would refuse to make, for the reason Why gives in the controller's words: a
+	// value a person gave sealed to a key the machine no longer has, a machine with no sealing key.
+	CredentialRefused CredentialState = "refused"
+)
+
+// Credential is the state of one pair credential, by the ends it joins: the provision, the consumer's node and module, the
+// provider's node, and the local name where a module keeps several (inv.Secret's key).
+type Credential struct {
+	Provision      string
+	Consumer       string
+	ConsumerModule string
+	Provider       string
+	Local          string
+	State          CredentialState
+	// Sealed is the consumer's copy as it is sealed to the consumer's key; optional, and only the controller's adapter passes it.
+	Sealed string
+	// Why is the words of a CredentialNotGiven or CredentialRefused.
+	Why string
+}