@zygoloid?

"comparing [...] in the [...] list [...] until the first index [...]" seems pretty clear to me that the intent is that you walk the elements of the list in the order in which they appear in the list. That said, I do agree that it's possible to read this as pulling indices from an unspecified set of indices in an unspecified order.

Adding an "(in increasing index order)" or similar seems sufficiently far into "clarification of obvious intent" category that I think I'd be comfortable adding that editorially. Would that satisfy your concern? (Note that due to /1's "It is unspecified whether virtual base class subobjects are compared more than once.", we don't actually want to say that each index is considered exactly once.)

Adding an "(in increasing index order)" or similar seems sufficiently far into "clarification of obvious intent" category that I think I'd be comfortable adding that editorially. Would that satisfy your concern?

Yes, that was my suggestion in #2729 (comment) - Jens wanted you to approve that such a clarification would be editorial.

(Note that due to /1's "It is unspecified whether virtual base class subobjects are compared more than once.", we don't actually want to say that each index is considered exactly once.)

The implication of the "list of subobjects" wording is that virtual base class subobjects may appear more than once in the list of subobjects. If that is the case each appearance would have a distinct index, so considering each index only once would not contradict that sentence.

The implication of the "list of subobjects" wording is that virtual base class subobjects may appear more than once in the list of subobjects.

That's not actually the case we care about, and it's not possible, because only direct base classes are in the list, and a virtual base class can be a direct base class at most once.

considering each index only once would not contradict that sentence.

The problem is not that we'd be restricted to consider each index at most once, the problem is that we'd be restricted to consider each index at least once. Consider:

struct A { friend std::strong_ordering operator<=>(A, A); };
struct B : virtual A {
  friend auto operator<=>(const B&, const B&) = default;
};
struct C : virtual A {
  friend auto operator<=>(const B&, const B&) = default;
  int n;
};
struct D : B, C {
  friend auto operator<=>(const B&, const B&) = default;
};

The expanded list of subobjects for C is exactly [A, n]. But when we compare the C subobject of D, we might want to skip the first index in the list, because we already compared the A subobject when comparing the B subobject of D.