List the provider-elsewhere store test, read a machine's domain as its profile, reuse the settings read once, and refuse a nested own name (hq ADR 0346, review 228)

cmd/mesh-controller/network.go

@@ -684,7 +684,7 @@ func artifactStoreOnNetwork(ctx context.Context, inv *inventory.Inventory,
 			if !offers {
 				continue
 			}
-			serves, err := servedOnNode(ctx, inv, machine, m, catalogue.ArtifactStoreProvision)
+			serves, _, err := servedOnNode(ctx, inv, machine, m, catalogue.ArtifactStoreProvision)
 			if err != nil {
 				return "", "", false, fmt.Errorf("reading where %s puts the artifact store: %w", machine, err)
 			}

cmd/mesh-controller/plan.go

@@ -291,10 +291,9 @@ func theRestOfTheMesh(ctx context.Context, inv *inventory.Inventory,
 		caps, _ := inv.ProfileOf(ctx, n.Name)
 		// Its public domain too (novox/hq ADR 0346): a provider elsewhere serves its own composed names,
 		// and composes them as its own plan does, under its own domain.
-		domain, err := inv.PublicDomainOf(ctx, n.Name)
-		if err != nil {
-			return catalogue.World{}, err
-		}
+		// Read as its profile is: a machine whose domain cannot be read (removed since the list was read)
+		// composes no public name, which leaves the key out and says so, and fails no other machine's plan.
+		domain, _ := inv.PublicDomainOf(ctx, n.Name)
 		others = append(others, candidate{
 			catalogue.Node{Name: n.Name, Site: siteOf[n.Name], Capabilities: caps,
 				At: onNetwork[n.Name], PublicDomain: domain}, theirs})
@@ -316,16 +315,12 @@ func theRestOfTheMesh(ctx context.Context, inv *inventory.Inventory,
 				// What that module says a consumer needs to know, with that node's settings on
 				// it: a port somebody moved on the provider is a port its consumers must be told
 				// about, and the two coming from different places is how they come to disagree.
-				serves, err := servedOnNode(ctx, inv, o.node.Name, m, name)
+				serves, layers, err := servedOnNode(ctx, inv, o.node.Name, m, name)
 				if err != nil {
 					return catalogue.World{}, err
 				}
 				// And its own composed names, as that node composes them (novox/hq ADR 0346): a name it
 				// does not compose leaves the key out, said under each consumer's need.
-				layers, err := inv.SettingsFor(ctx, o.node.Name, m.Module)
-				if err != nil {
-					return catalogue.World{}, err
-				}
 				serves, leftOut, err := got.ServedOwnNames(m, name, serves, catalogue.WithDefaults(m, layers))
 				if err != nil {
 					return catalogue.World{}, err
@@ -1592,19 +1587,20 @@ func managerPublicKeyFor(
 // artifact store's trust and the references composed through it (04-ISSUES/102). Unreadable
 // given ports are that node's refusal to report, not this reader's.
 func servedOnNode(ctx context.Context, inv *inventory.Inventory, node string,
-	m catalogue.Manifest, provision string) (map[string]any, error) {
+	m catalogue.Manifest, provision string) (map[string]any, []catalogue.Layer, error) {
 	ports, layers, err := portsGivenOn(ctx, inv, node, m)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	serves := catalogue.ServedOn(m, provision, ports)
 	if len(serves) > 0 {
 		serves, err = catalogue.Settle(serves, catalogue.WithDefaults(m, layers))
 		if err != nil {
-			return nil, err
+			return nil, nil, err
 		}
 	}
-	return serves, nil
+	// The layers too, read once, for what is filled after (novox/hq ADR 0346).
+	return serves, layers, nil
 }
 
 // portsGivenOn is where a node puts a module's ports — assigned, then given over them — and the