The indexer counts the modules on each old section, a tool reads it, and the judge refuses a section at 0 outside the foundation (issue 1966 D4)

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

@@ -54,6 +54,9 @@ type Indexer struct {
 	Taken Store
 	// Verdicts is the verdicts state (verdicts.go, novox/hq ADR 0578 §1); nil judges nothing.
 	Verdicts Store
+	// OldSections is the state of how many accepted modules use each old section (oldsections.go, issue 1966 D4); nil keeps no
+	// count and the judge refuses no use of an old section.
+	OldSections Store
 	// JudgeID names the judge a verdict says made it; empty is judge.Identity, the running program's.
 	JudgeID string
 	// SayRefused says the event manifest-refused for a refusal newly written; nil says nothing.

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

@@ -0,0 +1,78 @@
+package index
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"maps"
+	"slices"
+
+	"git.novox.be/novox/mesh-sdk/go/catalogue"
+	"git.novox.be/novox/mesh-sdk/go/delivery"
+
+	"mesh-delivery-indexer/judge"
+)
+
+// How many accepted modules use each old section (issue 1966 D4; novox/hq ADR 0595 §11): the indexer counts them, the
+// foundation left out, as it judges, keeps the count in its state oldsections under one key, and the tool
+// indexer_old_sections reads it. The judge refuses a manifest of another module that uses a section whose count is 0.
+const (
+	// OldSectionsTool is the tool that reads the count.
+	OldSectionsTool = "indexer_old_sections"
+	// OldSectionsState is the indexer's state of the count: the bucket mesh-delivery-indexer_oldsections.
+	OldSectionsState  = "oldsections"
+	OldSectionsBucket = delivery.IndexerModule + "_" + OldSectionsState
+	// OldSectionsKey is the one key it holds.
+	OldSectionsKey = "counts"
+)
+
+// OldSectionsCount is the value of the oldsections state: per old section, the accepted modules outside the foundation using it.
+type OldSectionsCount struct {
+	V      int            `json:"v"`
+	Counts map[string]int `json:"counts"`
+}
+
+// DecodeOldSections reads the oldsections value.
+func DecodeOldSections(value []byte) (OldSectionsCount, error) {
+	var c OldSectionsCount
+	if err := json.Unmarshal(value, &c); err != nil {
+		return c, fmt.Errorf("the count of the old sections cannot be read: %w", err)
+	}
+	if c.V != 1 {
+		return c, fmt.Errorf("a count of the old sections of version %d, not 1", c.V)
+	}
+	return c, nil
+}
+
+// countBefore counts the accepted modules using each old section as the pass starts: those whose verdict held says accepted,
+// or which have none and are not fresh (acceptedBefore). A manifest is read leniently, since a module the judge now finds
+// a problem in is still accepted (ADR 0579 §1) and still counts.
+func (ix *Indexer) countBefore(ctx context.Context, raws map[string][]byte, digests map[string]string, fresh map[string]bool) judge.OldSectionCounts {
+	var accepted []catalogue.Manifest
+	for _, name := range slices.Sorted(maps.Keys(raws)) {
+		if !ix.acceptedBefore(ctx, digests[name], fresh) {
+			continue
+		}
+		if m, err := catalogue.Decode(raws[name]); err == nil {
+			m.Module = name
+			accepted = append(accepted, m)
+		}
+	}
+	return judge.CountOldSections(accepted)
+}
+
+// keepOldSections writes the counts under OldSectionsKey when they differ from the ones held.
+func (ix *Indexer) keepOldSections(ctx context.Context, counts judge.OldSectionCounts) error {
+	if ix.OldSections == nil {
+		return nil
+	}
+	return write(ctx, ix.OldSections, OldSectionsKey, func(value []byte, found bool) ([]byte, bool, error) {
+		if found {
+			if cur, err := DecodeOldSections(value); err == nil && maps.Equal(cur.Counts, counts) {
+				return nil, false, nil
+			}
+		}
+		next, err := json.Marshal(OldSectionsCount{V: 1, Counts: counts})
+		return next, false, err
+	})
+}

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

@@ -75,7 +75,12 @@ func (ix *Indexer) JudgeAll(ctx context.Context, fresh map[string]bool) (Judged,
 		digests[name] = digest
 	}
 	predefined := ix.predefinedList(ctx)
-	refused, unnamed := judge.Shelf(raws, predefined, 0)
+	// The old sections end when no module is left in them (issue 1966 D4): counted from the verdicts held before this pass.
+	var counts judge.OldSectionCounts
+	if ix.OldSections != nil {
+		counts = ix.countBefore(ctx, raws, digests, fresh)
+	}
+	refused, unnamed := judge.ShelfCounting(raws, predefined, 0, counts)
 	for _, p := range unnamed {
 		ix.logf("judge: a problem between the manifests that no one module's removal ends, so it refuses none: %s", p)
 	}
@@ -84,6 +89,7 @@ func (ix *Indexer) JudgeAll(ctx context.Context, fresh map[string]bool) (Judged,
 	if id == "" {
 		id = judge.Identity()
 	}
+	var accepted []catalogue.Manifest
 	for _, name := range slices.Sorted(maps.Keys(digests)) {
 		out.Judged++
 		v := delivery.ManifestVerdict{Module: name, State: delivery.VerdictAccepted, Judge: id, At: ix.now()}
@@ -95,6 +101,12 @@ func (ix *Indexer) JudgeAll(ctx context.Context, fresh map[string]bool) (Judged,
 				v.State, v.Problems = delivery.VerdictRefused, problems
 			}
 		}
+		if !v.Refused() {
+			if m, err := catalogue.Decode(raws[name]); err == nil {
+				m.Module = name
+				accepted = append(accepted, m)
+			}
+		}
 		wrote, err := ix.writeVerdict(ctx, digests[name], v)
 		if errors.Is(err, process.ErrNotYet) {
 			return out, fmt.Errorf("the state %s is not on the bus yet: %w", VerdictsBucket, err)
@@ -121,6 +133,9 @@ func (ix *Indexer) JudgeAll(ctx context.Context, fresh map[string]bool) (Judged,
 			ix.logf("judge: modules.%s does not carry its verdict: %v", name, err)
 		}
 	}
+	if err := ix.keepOldSections(ctx, judge.CountOldSections(accepted)); err != nil {
+		ix.logf("judge: the count of the old sections is not kept: %v", err)
+	}
 	return out, nil
 }
 

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

@@ -135,6 +135,39 @@ func TestTheIndexerJudgesEveryManifestOnce(t *testing.T) {
 		string(accepted[0].BusState[0].Options["history"]) != "8" {
 		t.Fatalf("said accepted %+v", accepted)
 	}
+	// 1966/AC11: modules using state and none using logs but the foundation: logs counts 0, so a manifest of another
+	// module using logs is refused and the foundation's is accepted.
+	ix.OldSections = newMem()
+	hold("user", `{"module":"user","version":"1","state":["x"]}`)
+	hold("mesh-grants", `{"module":"mesh-grants","version":"1","logs":[{"name":"l"}]}`)
+	if _, err := ix.JudgeAll(ctx, nil); err != nil {
+		t.Fatal(err)
+	}
+	counts := func() map[string]int {
+		value, _, found, err := ix.OldSections.Get(ctx, OldSectionsKey)
+		if err != nil || !found {
+			t.Fatalf("no count of the old sections: %v", err)
+		}
+		c, err := DecodeOldSections(value)
+		if err != nil {
+			t.Fatal(err)
+		}
+		return c.Counts
+	}
+	if c := counts(); c["state"] != 1 || c["logs"] != 0 || c["streams"] != 0 || c["objects"] != 0 {
+		t.Fatalf("the old sections count %v, want state 1 and the rest 0", c)
+	}
+	late := hold("late", `{"module":"late","version":"1","logs":[{"name":"l"}]}`)
+	grants := hold("mesh-grants", `{"module":"mesh-grants","version":"2","logs":[{"name":"l"},{"name":"m"}]}`)
+	if _, err := ix.JudgeAll(ctx, map[string]bool{late: true, grants: true}); err != nil {
+		t.Fatal(err)
+	}
+	if v := verdict(late); !v.Refused() || !strings.Contains(v.Problems[0], "late uses the old section logs, which no other module uses any more") {
+		t.Fatalf("late: %+v", v)
+	}
+	if v := verdict(grants); v.Refused() {
+		t.Fatalf("the foundation's manifest was refused: %+v", v)
+	}
 	// Without the verdicts state the indexer judges nothing.
 	ix.Verdicts = nil
 	if j, err := ix.JudgeAll(ctx, nil); err != nil || j.Judged != 0 {