B5g7-1: the validation's job names no Go module; a Go bundle carries no package

Reverts the Go-bundle package of 53caa3ba; the run's program is the directory ./cmd/mesh-judge under the go.mod the build reads.

Builds: design 47 G §712, §676, §491, A-268

Claude-Session: https://claude.ai/code/session_01NcbgfGKaxw984XyAPfLm4h

modules/mesh-delivery-indexer/cmd/mesh-delivery-indexer/integration_test.go

@@ -120,21 +120,8 @@ func TestIndexerWhole(t *testing.T) { // 1238/AC2, AC10; 1585/T14, T15
 		if _, err := tc.Put(ctx, key, value); err != nil {
 			t.Fatal(err)
 		}
-		// The trunk holds the indexer's entry, taken in at an earlier commit with its own manifest; the seat git answers its go.mod, so
-		// its Go artifacts carry the Go module the validation's program is read under (§712, §676, A-263).
+		// The trunk holds the indexer's entry, taken in at an earlier commit with its own manifest; the validation names no Go module (A-268).
 		seedBuildModules(t, ctx, js, map[string]meshcatalog.CatalogEntry{index.Module: trunkIndexerEntry(t, ctx, js)})
-		if _, err := js.Conn().Subscribe("mesh.seat.git.tool.file", func(m *nats.Msg) {
-			var a git.FileInput
-			_ = json.Unmarshal(m.Data, &a)
-			answer := git.FileAnswer{Path: a.Path, Ref: a.Ref, Absent: true}
-			if a.Path == "modules/"+index.Module+"/go.mod" {
-				answer = git.FileAnswer{Path: a.Path, Ref: a.Ref, Content: "module " + index.Module + "\n"}
-			}
-			raw, _ := json.Marshal(map[string]any{"result": answer, "node": "n0"})
-			_ = m.Respond(raw)
-		}); err != nil {
-			t.Fatal(err)
-		}
 		validations = standInBuildSeat(t, ctx, js, &refusing)
 		// The node-engine's composition on n1 (process.Conn.Call's subjects): the build of the indexer that runs there.
 		answer := func(m *nats.Msg) {
@@ -295,7 +282,7 @@ func TestIndexerWhole(t *testing.T) { // 1238/AC2, AC10; 1585/T14, T15
 	// the revision's head, and no heads; accepted, it is never asked again while it waits for the named indexer.
 	if asks := validations.asked(); len(asks) != 1 || asks[0].Run == nil || asks[0].Kind != sdkstep.AskCheck ||
 		asks[0].Run.Program.Repository != m1.Repository || asks[0].Run.Program.Dir != "modules/"+ix || asks[0].Run.Program.Commit != m1.Merge ||
-		len(asks[0].Run.Heads) != 0 || !strings.HasSuffix(asks[0].Run.Program.Package, "/cmd/mesh-judge") {
+		len(asks[0].Run.Heads) != 0 || asks[0].Run.Program.Package != "./cmd/mesh-judge" {
 		t.Fatalf("validation asks = %+v, want one run of the indexer's manifest validator at %s", asks, m1.Merge)
 	}
 	get := func(bucket, key string) ([]byte, bool) {

modules/mesh-delivery-indexer/internal/index/artifacts.go

@@ -13,7 +13,7 @@ import (
 
 // Each entry carries its artifacts' package names (design 47 G §676, §491, §478, §504, §412): at take-in the indexer reads
 // each artifact's package name from the revision's own files at the artifact's path, the module of its go.mod for a Go
-// package and for a Go bundle (A-263), the name of its package.json for an npm package, the module's and the artifact's names joined by / for an image artifact (§694), and writes it into
+// package, the name of its package.json for an npm package, the module's and the artifact's names joined by / for an image artifact (§694), and writes it into
 // the entry's artifact as package, {ecosystem, name}. The manifest validator judges §491 from these fields.
 
 // Package ecosystems of an artifact's package (§676).
@@ -47,16 +47,13 @@ func (ix *Indexer) withArtifacts(ctx context.Context, e meshcatalog.CatalogEntry
 
 // packageOf is the package name of artifact a of the entry e: read through the forge at the entry's commit, kept per
 // repository, commit, path and artifact so a later entry of the same commit reads nothing; nil for an artifact that names
-// none (a program or an archive not built from a Go module) or whose name cannot be read now.
+// none (a program, an archive) or whose name cannot be read now.
 func (ix *Indexer) packageOf(ctx context.Context, e meshcatalog.CatalogEntry, a catalogue.Artifact) *meshcatalog.ArtifactPackage {
-	switch {
-	case a.Kind == catalogue.ArtifactPackage:
-	case a.Kind == catalogue.ArtifactImage:
+	switch a.Kind {
+	case catalogue.ArtifactPackage:
+	case catalogue.ArtifactImage:
 		// An image's package name is its module's name and its artifact's joined by `/`, read from no file (§694).
 		return &meshcatalog.ArtifactPackage{Ecosystem: EcosystemImage, Name: e.Module + "/" + a.Name}
-	case a.Language == "go":
-		// A Go artifact of any kind, a bundle too, is built from the Go module its go.mod names (design 47 G A-263): the manifest
-		// validator's program is read under it (§712).
 	default:
 		return nil
 	}

modules/mesh-delivery-indexer/internal/index/catalog_graph_test.go

@@ -33,12 +33,11 @@ func TestAnEntryCarriesItsManifestWholeAndTheDigestOfItsBytes(t *testing.T) {
 }
 
 // Design 47 G §676: at take-in the entry's artifacts carry the package name read from the revision's own files at the
-// artifact's path: the module of a go.mod, the name of a package.json; a Go bundle the module of its go.mod (A-263).
+// artifact's path: the module of a go.mod, the name of a package.json.
 func TestAnEntryCarriesItsArtifactsPackageNames(t *testing.T) {
 	ix := &Indexer{ReadFile: func(_ context.Context, repository, sha, path string) ([]byte, error) {
 		files := map[string]string{
 			"mods/m/go/go.mod":       "module git.example/m/go\n\ngo 1.26\n",
-			"mods/m/go.mod":          "module git.example/m\n",
 			"mods/m/js/package.json": `{"name":"@example/m"}`,
 		}
 		if repository != "r" || sha != "c1" {
@@ -54,7 +53,6 @@ func TestAnEntryCarriesItsArtifactsPackageNames(t *testing.T) {
 		{Name: "jspkg", Kind: catalogue.ArtifactPackage, Language: "typescript", Paths: []string{"js"}},
 		{Name: "img", Kind: catalogue.ArtifactImage},
 		{Name: "prog", Kind: "bundle", Language: "go"},
-		{Name: "web", Kind: "bundle", Language: "typescript"},
 	}}}
 	e := ix.withArtifacts(context.Background(), meshcatalog.CatalogEntry{Module: "m", Repository: "r", Path: "mods/m", Commit: "c1"}, m)
 	got := map[string]string{}
@@ -65,8 +63,7 @@ func TestAnEntryCarriesItsArtifactsPackageNames(t *testing.T) {
 		}
 		got[a.Ref] = name
 	}
-	want := map[string]string{"m:gopkg": "go git.example/m/go", "m:jspkg": "npm @example/m", "m:img": "image m/img",
-		"m:prog": "go git.example/m", "m:web": "none"} // A-263: a Go bundle carries the Go module its go.mod names
+	want := map[string]string{"m:gopkg": "go git.example/m/go", "m:jspkg": "npm @example/m", "m:img": "image m/img", "m:prog": "none"}
 	if !reflect.DeepEqual(got, want) {
 		t.Errorf("artifacts' packages %v, want %v (§676)", got, want)
 	}

modules/mesh-delivery-indexer/internal/index/validate.go

@@ -178,22 +178,13 @@ func (ix *Indexer) trunkDefinitions(ctx context.Context) (map[string]json.RawMes
 	return defs, nil
 }
 
-// validationJob is the run of the manifest validator for the request (§712): the program cmd/mesh-judge under the Go module
-// the indexer entry's Go artifact names, at the entry's path, built at head, the revision's head of the entry's repository; no
+// validationJob is the run of the manifest validator for the request (§712): the program cmd/mesh-judge, its directory under
+// the Go module the go.mod at the entry's path names (read by the build, A-268), at the entry's path, built at head, the revision's head of the entry's repository; no
 // heads and no arguments; the input the request's bytes, served by the seat mesh-catalog's verb input.
 func validationJob(indexer meshcatalog.CatalogEntry, head, branch string, seq uint64, input []byte) (buildstep.RunJob, error) {
-	var pkg string
-	for _, a := range indexer.Artifacts {
-		if a.Language == buildstep.AskGo && a.Package != nil && a.Package.Name != "" {
-			pkg = a.Package.Name
-			break
-		}
-	}
 	switch {
 	case indexer.Repository == "":
 		return buildstep.RunJob{}, fmt.Errorf("no entry of the revision claims the seat %s", validationCatalogSeat)
-	case pkg == "":
-		return buildstep.RunJob{}, fmt.Errorf("the indexer entry %s names no Go artifact's package", indexer.Module)
 	case head == "":
 		return buildstep.RunJob{}, fmt.Errorf("the revision names no head of %s, the repository of the indexer entry %s", indexer.Repository, indexer.Module)
 	}
@@ -206,7 +197,7 @@ func validationJob(indexer meshcatalog.CatalogEntry, head, branch string, seq ui
 		dir = "."
 	}
 	return buildstep.RunJob{
-		Program: buildstep.RunProgram{Repository: indexer.Repository, Commit: head, Dir: dir, Package: pkg + "/" + validationProgram},
+		Program: buildstep.RunProgram{Repository: indexer.Repository, Commit: head, Dir: dir, Package: "./" + validationProgram},
 		Input:   in,
 		Reader:  fmt.Sprintf("manifest validator of %s at %d", branchName(branch), seq),
 	}, nil

modules/mesh-delivery-indexer/internal/index/validate_test.go

@@ -62,12 +62,12 @@ func TestValidationRefusesWhatTheRevisionCauses(t *testing.T) {
 	}
 	head := strings.Repeat("a", 40)
 	entry := meshcatalog.CatalogEntry{Module: "mesh-delivery-indexer", Repository: "novox/mesh-delivery", Path: "modules/mesh-delivery-indexer",
-		Artifacts: []meshcatalog.Artifact{{Language: "go", Package: &meshcatalog.ArtifactPackage{Ecosystem: "go", Name: "mesh-delivery-indexer"}}}}
+		Artifacts: []meshcatalog.Artifact{{Language: "go", Kind: "bundle"}}}
 	job, err := validationJob(entry, head, "main", 7, []byte(`{"v":1}`))
 	if err != nil {
 		t.Fatal(err)
 	}
-	want := buildstep.RunProgram{Repository: "novox/mesh-delivery", Commit: head, Dir: "modules/mesh-delivery-indexer", Package: "mesh-delivery-indexer/cmd/mesh-judge"}
+	want := buildstep.RunProgram{Repository: "novox/mesh-delivery", Commit: head, Dir: "modules/mesh-delivery-indexer", Package: "./cmd/mesh-judge"}
 	if job.Program != want || len(job.Heads) != 0 || len(job.Args) != 0 || job.Input.Verb != "seat:mesh-catalog.input" || job.Reader != "manifest validator of main at 7" {
 		t.Errorf("the job %+v", job)
 	}