A module may declare its own seats (novox/hq ADR 0118)

The manifest carries seats and uses; registration refuses a mesh-* name, a
duplicate declarer, an undeclared uses or claim, a seat with no protocol, a
scope mismatch, and a holder that does not answer what its seat promises.

The parser stops judging unknown claim names, because it cannot: another
module may declare that seat, and one manifest cannot tell. The test that
encoded the old rule is rewritten to assert the refusal at registration, and
a new one pins the case the parser could not have distinguished.

Tools are declared for the first time, under their own key — serves already
means a provision's facts.

internal/catalogue/seats_test.go

@@ -54,17 +54,40 @@ func claimed(claims string) []byte {
 	return []byte(`{"module":"thing","version":"1","provides":[{"name":"npm-package-registry","scope":"mesh"}],"claims":` + claims + `}`)
 }
 
-func TestAClaimOnASeatTheMeshDoesNotDefineIsRefused(t *testing.T) {
-	_, err := ParseManifest(claimed(`[{"name":"the-anything","scope":"node"}]`))
-	if err == nil {
-		t.Fatal("a module invented a seat by claiming it")
+// **The refusal moved, it did not go** (novox/hq ADR 0118, superseding 0110). A module may now
+// declare its own seats, so whether a claimed seat exists is a fact about the *catalogue* and not
+// about the manifest in front of the parser: a claim on a seat another registered module declares
+// is perfectly good, and the parser cannot tell the two cases apart. So the parser accepts it and
+// registration refuses it — the same guarantee, at the same moment work would otherwise start,
+// from a set nobody maintains by hand.
+func TestAClaimOnASeatNobodyDeclaresIsRefusedAtRegistration(t *testing.T) {
+	m, err := ParseManifest(claimed(`[{"name":"the-anything","scope":"node"}]`))
+	if err != nil {
+		t.Fatalf("the parser judged a claim it cannot judge alone: %v", err)
 	}
-	if !strings.Contains(err.Error(), "the-anything") || !strings.Contains(err.Error(), "not a seat") {
-		t.Fatalf("the refusal does not say the seat is unknown: %v", err)
+
+	problems := CatalogueProblems(Shelf{m.Module: m})
+	if len(problems) == 0 {
+		t.Fatal("a module invented a seat by claiming it, and registration allowed it")
 	}
-	// And it says what the seats are, because "no" without the list sends somebody reading code.
-	if !strings.Contains(err.Error(), "the-packet-filter") {
-		t.Fatalf("the refusal does not list the seats: %v", err)
+	joined := strings.Join(problems, "; ")
+	if !strings.Contains(joined, "the-anything") || !strings.Contains(joined, "no module declares") {
+		t.Fatalf("the refusal does not say the seat is nobody's: %v", problems)
+	}
+}
+
+// And the same claim is fine once something declares that seat, which is the case the parser
+// could not have distinguished.
+func TestAClaimOnASeatAnotherModuleDeclaresIsAccepted(t *testing.T) {
+	claimant, err := ParseManifest(claimed(`[{"name":"the-anything","scope":"node"}]`))
+	if err != nil {
+		t.Fatal(err)
+	}
+	declarer := Manifest{Module: "someone", Seats: []SeatDeclaration{
+		{Name: "the-anything", Scope: ScopeNode, Accepts: []string{"work"}},
+	}}
+	if problems := CatalogueProblems(Shelf{claimant.Module: claimant, "someone": declarer}); len(problems) != 0 {
+		t.Fatalf("a claim on a declared seat was refused: %v", problems)
 	}
 }