A build records the bases it was handed, and the mesh reads its edges from builds

Bases reach a recipe as build arguments, so the digest was never in the file the builder read
edges from: no build on the mesh recorded what it stood on, and 'build --on', the bases-first
order and the merge follow-up all walked a graph with no edges (novox/hq 04-ISSUES/131). The
builder now reports every base it resolved; the controller records them by artifact path and
reads the newest build's edges from the store, since a recorded manifest carries no build.on.

cmd/mesh-controller/build.go

@@ -42,23 +42,21 @@ func buildOn(ctx context.Context, base string, wait time.Duration) error {
 	if err != nil {
 		return err
 	}
+	against, err := open.inventory.BuiltAgainst(ctx)
+	if err != nil {
+		return err
+	}
 	var on []inventory.Entry
 	for _, e := range held {
-		if e.Manifest.Build == nil {
-			continue
-		}
-		for _, b := range e.Manifest.Build.On {
-			if standsOnModule(b, base) {
-				on = append(on, e)
-				break
-			}
+		if standsOnModule(e, base, against) {
+			on = append(on, e)
 		}
 	}
 	if len(on) == 0 {
 		fmt.Printf("nothing the mesh holds stands on %s\n", base)
 		return nil
 	}
-	on = orderByBases(on)
+	on = orderByBases(on, against)
 	fmt.Printf("%d module(s) stand on %s:\n", len(on), base)
 	var failed []string
 	for _, e := range on {
@@ -134,8 +132,9 @@ func buildCommand(ctx context.Context, args []string) error {
 //
 // **By digest and path, never by where it was pushed** (novox/hq 04-ISSUES/102). The builder
 // says `<registry>:<port>/<module>/<artifact>@sha256:…`; the mesh records the artifact-store
-// reference and composes the store's address back in where a reference is used. `against` is kept
-// as announced: it is what the build stood on as the builder saw it, and the catalogue's edge.
+// reference and composes the store's address back in where a reference is used. `against` — what
+// the build stood on, the catalogue's edge — is recorded the same way, so an edge names a module's
+// artifact and not the machine it was pulled from.
 func buildFrom(result link.BuildResult) inventory.Build {
 	kept := inventory.Build{
 		ID: result.ID, Repository: result.Repository, Ref: result.Ref,
@@ -145,7 +144,10 @@ func buildFrom(result link.BuildResult) inventory.Build {
 		// edges, and it is not always listening when a build happens — on a fresh mesh it cannot
 		// be, for exactly the modules it needs most. Keeping them is what makes a replay able to
 		// rebuild the graph rather than a list of names.
-		Path: result.Path, Against: result.Against,
+		Path: result.Path,
+	}
+	for _, ref := range result.Against {
+		kept.Against = append(kept.Against, catalogue.Recorded(ref))
 	}
 	var announced []inventory.Artifact
 	for _, made := range result.Made {
@@ -344,7 +346,11 @@ func buildBehind(ctx context.Context, wait time.Duration) error {
 
 	// Bases first: a module built before the module it stands on is built against the old one
 	// and reports success (novox/hq 04-ISSUES/131).
-	stale = orderByBases(stale)
+	against, err := inv.BuiltAgainst(ctx)
+	if err != nil {
+		return err
+	}
+	stale = orderByBases(stale, against)
 
 	var failed []string
 	for _, e := range stale {

cmd/mesh-controller/order_test.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"strings"
 	"testing"
 
 	"github.com/novox/mesh-controller/internal/catalogue"
@@ -8,19 +9,28 @@ import (
 	"github.com/novox/mesh-controller/internal/link"
 )
 
-func entry(module string, on ...string) inventory.Entry {
-	b := &catalogue.Build{}
-	for _, o := range on {
-		b.On = append(b.On, catalogue.BuildsOn{Arg: "X", Module: o, Artifact: "runtime"})
+// entry is a module as the catalogue holds it: built, so its manifest carries no `build` any more.
+func entry(module string, _ ...string) inventory.Entry {
+	return inventory.Entry{Manifest: catalogue.Manifest{Module: module}}
+}
+
+// stoodOn is what each module's newest build recorded it was handed.
+func stoodOn(edges map[string][]string) map[string][]string {
+	out := map[string][]string{}
+	for module, bases := range edges {
+		for _, b := range bases {
+			out[module] = append(out[module], catalogue.ArtifactStoreScheme+b+"/runtime@sha256:"+strings.Repeat("0", 64))
+		}
 	}
-	return inventory.Entry{Manifest: catalogue.Manifest{Module: module, Build: b}}
+	return out
 }
 
 // A module built before the module it stands on is built against the old one and reports success
 // (novox/hq 04-ISSUES/131). So bases come first, however the set arrived.
 func TestBasesAreBuiltBeforeWhatStandsOnThem(t *testing.T) {
-	in := []inventory.Entry{entry("app", "runtime"), entry("runtime", "base"), entry("other"), entry("base")}
-	got := orderByBases(in)
+	in := []inventory.Entry{entry("app"), entry("runtime"), entry("other"), entry("base")}
+	edges := stoodOn(map[string][]string{"app": {"runtime"}, "runtime": {"base"}})
+	got := orderByBases(in, edges)
 	pos := map[string]int{}
 	for i, e := range got {
 		pos[e.Manifest.Module] = i
@@ -32,12 +42,31 @@ func TestBasesAreBuiltBeforeWhatStandsOnThem(t *testing.T) {
 		t.Fatalf("an entry was lost or doubled: %d", len(got))
 	}
 	// A base outside the set is not waited for: it is not being rebuilt.
-	got = orderByBases([]inventory.Entry{entry("app", "elsewhere")})
+	got = orderByBases([]inventory.Entry{entry("app")}, stoodOn(map[string][]string{"app": {"elsewhere"}}))
 	if len(got) != 1 {
 		t.Fatalf("a dependency outside the set changed the set: %v", got)
 	}
 }
 
+// A module registered from its manifest and never built still names its bases there; once built,
+// the recorded edge is what says so. Both are read, and a module never stands on itself.
+func TestWhatStandsOnAModuleIsReadFromItsBuildOrItsManifest(t *testing.T) {
+	built := entry("gitea")
+	edges := stoodOn(map[string][]string{"gitea": {"mesh-tools"}})
+	if !standsOnModule(built, "mesh-tools", edges) {
+		t.Fatal("a recorded edge was not read")
+	}
+	if standsOnModule(built, "gitea", edges) || standsOnModule(built, "postgres", edges) {
+		t.Fatal("an edge was invented")
+	}
+	fresh := inventory.Entry{Manifest: catalogue.Manifest{Module: "plex", Build: &catalogue.Build{
+		On: []catalogue.BuildsOn{{Arg: "RUNTIME_BASE", Module: "mesh-tools", Artifact: "runtime"}},
+	}}}
+	if !standsOnModule(fresh, "mesh-tools", nil) {
+		t.Fatal("a manifest's own base was not read")
+	}
+}
+
 // A merge names a repository the way the forge does; a source is recorded the way a build was
 // asked for. The two meet on owner/repo and branch, whichever form the record took.
 func TestAMergeMatchesTheSourcesBuiltFromIt(t *testing.T) {

cmd/mesh-controller/upgrades.go

@@ -250,7 +250,11 @@ func (f following) SourceMoved(ctx context.Context, m link.SourceMoved) error {
 			m.Owner, m.Repo, m.Base, m.Commit)
 		return nil
 	}
-	ordered := orderByBases(moved)
+	against, err := inv.BuiltAgainst(ctx)
+	if err != nil {
+		return notNow(err)
+	}
+	ordered := orderByBases(moved, against)
 	names := make([]string, 0, len(ordered))
 	for _, e := range ordered {
 		names = append(names, e.Manifest.Module)
@@ -265,7 +269,7 @@ func (f following) SourceMoved(ctx context.Context, m link.SourceMoved) error {
 			failed = append(failed, e.Manifest.Module)
 			// A base that failed is a reason to stop: what stands on it would be built against
 			// the old one, and report success (novox/hq 04-ISSUES/131).
-			if standsOn(ordered, e.Manifest.Module) {
+			if standsOn(ordered, e.Manifest.Module, against) {
 				fmt.Printf("  stopping: %s is a base of what was still to build\n", e.Manifest.Module)
 				break
 			}
@@ -292,10 +296,13 @@ func sourceIs(s inventory.Source, m link.SourceMoved) bool {
 	return s.Ref == "" || s.Ref == m.Base
 }
 
-// orderByBases is the entries with every base before what stands on it: a module whose build names
-// another's artifact under build.on comes after that module. Entries outside the set are not
-// waited for — they are not being rebuilt. Stable for what has no order between it.
-func orderByBases(entries []inventory.Entry) []inventory.Entry {
+// orderByBases is the entries with every base before what stands on it: a module whose build stood
+// on another's artifact comes after that module. Entries outside the set are not waited for — they
+// are not being rebuilt. Stable for what has no order between it.
+//
+// `against` is what each module's newest build stood on (inventory.BuiltAgainst): the edges are
+// derived from builds, not declared, because a recorded manifest no longer carries `build.on`.
+func orderByBases(entries []inventory.Entry, against map[string][]string) []inventory.Entry {
 	inSet := map[string]bool{}
 	for _, e := range entries {
 		inSet[e.Manifest.Module] = true
@@ -309,13 +316,9 @@ func orderByBases(entries []inventory.Entry) []inventory.Entry {
 			return
 		}
 		seen[name] = true
-		if e.Manifest.Build != nil {
-			for _, on := range e.Manifest.Build.On {
-				for _, base := range entries {
-					if base.Manifest.Module != name && inSet[base.Manifest.Module] && standsOnModule(on, base.Manifest.Module) {
-						place(base, seen)
-					}
-				}
+		for _, base := range entries {
+			if base.Manifest.Module != name && inSet[base.Manifest.Module] && standsOnModule(e, base.Manifest.Module, against) {
+				place(base, seen)
 			}
 		}
 		placed[name] = true
@@ -328,26 +331,34 @@ func orderByBases(entries []inventory.Entry) []inventory.Entry {
 }
 
 // standsOn is whether anything in the set is built on the named module's artifacts.
-func standsOn(entries []inventory.Entry, module string) bool {
+func standsOn(entries []inventory.Entry, module string, against map[string][]string) bool {
 	for _, e := range entries {
-		if e.Manifest.Build == nil {
-			continue
-		}
-		for _, on := range e.Manifest.Build.On {
-			if standsOnModule(on, module) {
-				return true
-			}
+		if standsOnModule(e, module, against) {
+			return true
 		}
 	}
 	return false
 }
 
-// standsOnModule is whether a base names the module: as written in a manifest (`module`), or as
-// recorded after a build, when the mesh has replaced it with the artifact it resolved to
-// (`artifact-store://<module>/<artifact>@…`). A recorded manifest is what the catalogue holds.
-func standsOnModule(on catalogue.BuildsOn, module string) bool {
-	if on.Module == module {
-		return true
+// standsOnModule is whether an entry's build stood on the named module: by what its newest build
+// recorded it was handed (`artifact-store://<module>/<artifact>@…`, the module's own artifact), or
+// — for a module registered from a manifest and not yet built — by the base its manifest names.
+func standsOnModule(e inventory.Entry, module string, against map[string][]string) bool {
+	if e.Manifest.Module == module {
+		return false
 	}
-	return strings.HasPrefix(on.Image, "artifact-store://"+module+"/")
+	if e.Manifest.Build != nil {
+		for _, on := range e.Manifest.Build.On {
+			if on.Module == module {
+				return true
+			}
+		}
+	}
+	prefix := catalogue.ArtifactStoreScheme + module + "/"
+	for _, ref := range against[e.Manifest.Module] {
+		if strings.HasPrefix(ref, prefix) {
+			return true
+		}
+	}
+	return false
 }