A module can tell its provider what it needs

`requires` said a thing must be there. It never said what to do with it,
so a web application requiring a reverse proxy had nowhere to put "this
name, this port". The two modules that needed it most went round the
outside and opened a connection to the control plane's database, which is
why every node holds a credential to it permanently.

Two fields close it:

  contributes: {reverse-proxy: {host: board, port: 8080}}
  receives:    {reverse-proxy: /etc/traefik/dynamic/mesh.json}

The control plane collects every contribution on a node and writes them
to the path the provider named, ordered by module so the file does not
churn. Contributing to something is requiring it — asking to be published
means a publisher must exist, and a module that had to say both would
eventually say one.

The control plane does not know what a reverse proxy is and does not
write one's configuration. It delivers facts; the module turns them into
whatever it runs. That is why swapping the proxy touches nothing that
publishes through it, and why the host needs no new vocabulary — a
received file is a file.

Settings reach a contribution the same way they reach a file, because a
hostname is exactly what differs between one mesh and the next.

Two things found by running it:

- the file had a `//` header, so it said "do not edit" to a person and
  failed to parse for the program meant to read it. The note is inside
  the document now.
- a provider with no consumers gets an empty file rather than none. It
  cannot otherwise tell "nothing asked for me" from "the mesh never
  wrote it", and those want different responses.

Also `plan <node> --json`, which is how the declaration gets handed to
the host's own parser.

internal/catalogue/resolve.go

@@ -1,6 +1,7 @@
 package catalogue
 
 import (
+	"encoding/json"
 	"errors"
 	"fmt"
 	"sort"
@@ -150,7 +151,7 @@ func Resolve(catalogue map[string]Manifest, assigned []string, node Node, elsewh
 			because[m.Module] = fmt.Sprintf("required by %s", because[want])
 		}
 
-		for _, r := range m.Requires {
+		for _, r := range m.Wants() {
 			if _, ok := because[r]; !ok {
 				because[r] = m.Module
 			}
@@ -305,9 +306,21 @@ type Rendering struct {
 // both call something "config", and without this the second would silently replace the first —
 // the node applying one of them and reporting success.
 func (r Resolution) Declaration(with Rendering) ([]map[string]any, error) {
+	given, err := r.contributions(with.Settings)
+	if err != nil {
+		return nil, err
+	}
+
 	var out []map[string]any
 	for _, m := range r.Modules {
 		resources := m.Resources
+		for _, to := range sortedKeys(m.Receives) {
+			file, err := receivedFile(to, m.Receives[to], given[to])
+			if err != nil {
+				return nil, err
+			}
+			resources = append(append([]map[string]any{}, resources...), file)
+		}
 		if m.Computed != "" {
 			generator, known := with.Generators[m.Computed]
 			if !known {
@@ -351,3 +364,76 @@ func (r Resolution) Declaration(with Rendering) ([]map[string]any, error) {
 	}
 	return out, nil
 }
+
+// Contribution is one module telling the answer to a requirement what it needs from it.
+type Contribution struct {
+	// From is the module that said it, so the provider and a person reading the file can tell
+	// which route belongs to what.
+	From string `json:"from"`
+	// Values are the module's own, with settings applied. What the keys mean is agreed by the
+	// requirement's name — everything providing `reverse-proxy` understands the same shape, which
+	// is what makes swapping one for another cost nothing.
+	Values map[string]any `json:"values"`
+}
+
+// contributions collects what every module in this set contributes, by requirement.
+//
+// Ordered by contributing module, because the result becomes a file on a machine and a file whose
+// lines move about is a file that looks changed when nothing changed.
+func (r Resolution) contributions(settings SettingsBy) (map[string][]Contribution, error) {
+	out := map[string][]Contribution{}
+	modules := append([]Manifest{}, r.Modules...)
+	sort.Slice(modules, func(i, j int) bool { return modules[i].Module < modules[j].Module })
+
+	for _, m := range modules {
+		for _, to := range sortedKeys(m.Contributes) {
+			// Settings reach a contribution the same way they reach a file. A route's hostname is
+			// exactly the kind of thing that differs between one mesh and the next, and a module
+			// that could not have it set would have to be edited to be reused.
+			values, err := settle(m.Contributes[to], settings[m.Module], nil,
+				m.Module+" contributing to "+to)
+			if err != nil {
+				return nil, fmt.Errorf("%s contributing to %s: %w", m.Module, to, err)
+			}
+			out[to] = append(out[to], Contribution{From: m.Module, Values: values})
+		}
+	}
+	return out, nil
+}
+
+// receivedFile is the file a provider is given its consumers' contributions in.
+func receivedFile(requirement, path string, given []Contribution) (map[string]any, error) {
+	if given == nil {
+		// Nobody contributed. The file is still written, empty, rather than left absent: a
+		// provider that finds no file cannot tell "nothing asked for me" from "the mesh never
+		// wrote it", and the two want completely different responses.
+		given = []Contribution{}
+	}
+	// The note goes *inside* the document, not above it. The first version wrote a `//` header
+	// and produced a file that says "do not edit" to a person and fails to parse for the program
+	// meant to read it — which is the whole audience.
+	body, err := json.MarshalIndent(map[string]any{
+		"contributions": 1,
+		"requirement":   requirement,
+		"generated": "by the mesh — do not edit; replaced whenever a module contributing to " +
+			requirement + " arrives or leaves",
+		"given": given,
+	}, "", "  ")
+	if err != nil {
+		return nil, err
+	}
+	return map[string]any{
+		"id": ReceivedID(requirement), "type": "file", "path": path, "mode": "0644",
+		"content": string(body) + "\n",
+	}, nil
+}
+
+// sortedKeys is map iteration made repeatable, which everything written to a machine needs.
+func sortedKeys[V any](m map[string]V) []string {
+	out := make([]string, 0, len(m))
+	for k := range m {
+		out = append(out, k)
+	}
+	sort.Strings(out)
+	return out
+}