Something answered on this machine is still bound

A binding was skipped when the provider turned out to be on the same node,
reasoning that a file saying "it is on this node" is a fact nobody needs. That
is right about the location and wrong about everything beside it: a binding
also carries what the provider said a consumer must know, which is the port,
and a consumer cannot invent that.

A build machine sharing a node with the registry it pushes to sat in a loop
saying it could not read its own binding. Nothing was wrong with the machine,
the module, the credential or the provision — the file was never written, and
the absence looked exactly like a mistake in the module.

The original intent is kept where it was right: a provision whose provider said
nothing a consumer must know is still not written. A shell is answered here and
there is nothing to say about it. A registry is answered here and the port is
still unguessable.

The address is this machine's name on the private network, or loopback when it
has none — a machine off the network still reaches itself, and a name nothing
resolves is worse than an address that always works.

internal/catalogue/declaration.go

@@ -193,10 +193,22 @@ func (r Resolution) Declaration(with Rendering) ([]map[string]any, error) {
 				}
 			}
 			if found == nil {
-				// Bound to something answered on this machine rather than from the mesh. Nothing
-				// to write: the answer is here, and a file saying "it is on this node" would be
-				// a fact nobody needs and one more thing to keep true.
-				continue
+				// Answered on this same machine rather than from elsewhere in the mesh.
+				//
+				// **Still written.** It used to be skipped, reasoning that "it is on this node"
+				// is a fact nobody needs — and that is true of the *location* and false of
+				// everything beside it. A binding also carries what the provider said a consumer
+				// must know, which is the port; a consumer cannot invent that, and got an absent
+				// file with no explanation. A build machine sharing a node with the registry it
+				// pushes to sat in a loop saying it could not read its own binding.
+				here := here(r, to)
+				if here == nil {
+					// Nothing in this node's set offers it either, so there is genuinely nothing
+					// to say. Resolution has already refused anything unanswerable, so this is a
+					// requirement met by the module itself.
+					continue
+				}
+				found = here
 			}
 			file, err := boundFile(*found, m.Binds[to])
 			if err != nil {
@@ -429,3 +441,28 @@ func (r Resolution) ContributionsTo(requirement string, settings SettingsBy) (
 	}
 	return given[0].From, given[0].Values, nil
 }
+
+// here is the module on this same machine that answers a requirement, as a binding.
+//
+// **Only when the provider said something a consumer must know.** That is the line: the original
+// reasoning — a file saying "it is on this node" is a fact nobody needs — is right about the
+// location and wrong about everything beside it. A shell is answered here and there is nothing to
+// say about it. A registry is answered here and the consumer still cannot guess the port.
+//
+// The address is this machine's own name on the private network when it has one, and loopback
+// when it does not — a machine not on the network still reaches itself, and naming it by a name
+// nothing resolves would be worse than naming it by an address that always works.
+func here(r Resolution, requirement string) *Needed {
+	for _, m := range r.Modules {
+		serves, said := m.Serves[requirement]
+		if !said || len(serves) == 0 {
+			continue
+		}
+		at := r.At
+		if at == "" {
+			at = "127.0.0.1"
+		}
+		return &Needed{Name: requirement, From: r.Node, At: at, Serves: serves}
+	}
+	return nil
+}